Entries:
Comments:
Discussions:

Loading user information from Channel 9

Something went wrong getting user information from Channel 9

Latest Achievement:

Loading user information from MSDN

Something went wrong getting user information from MSDN

Visual Studio Achievements

Latest Achievement:

Loading Visual Studio Achievements

Something went wrong getting the Visual Studio Achievements

Discussions

Bass Bass Knows the way the wind is flowing.
  • The Radio

    jamie said:
    Dodo said:
    *snip*

    hahahaha

    i know!

    i just cant get past sonors ...um..install instructions (patch.exe doesnt patch!)

     

    so im keeping everything as wavs ...

     

    you want to hear how bad i play (after 20 yrs?)

     

    www.jgrant.com/TRK1-00.wav

    http://www.jgrant.com/TRK10-00.wav

     

    ..then again... i always made stuff up on the fly...  whatever

    i got help coming. Smiley

     

     

  • The Radio

    jamie said:
    jeffsand said:
    *snip*

    X’s and O’s

     

    http://www.jgrant.com/xando.wav

     

    needs keyboards… or something to pull it together

     

    sort of need me too- meets- stone temple pilots.. with a bit of pink spiders/floyd and twist and shout

     

    I wish there was a “make perfect” button…

     

     

     

    </thread>

  • Ideas for C# 5.0

    exoteric said:
    Bass said:
    *snip*

    Not quite sure what you mean but this work impresses me

     

    http://www.cse.unsw.edu.au/~dons/papers/CLS07.html 

    This paper presents an automatic fusion system, stream fusion, based on equational transformations, that fuses a wider range of functions than existing short-cut fusion systems. In particular, stream fusion is able to fuse zips, left folds and functions over nested lists, including list comprehensions. A distinguishing feature of the stream fusion framework is its simplicity: by transforming list functions to expose their structure, intermediate values are eliminated by general purpose compiler optimisations.
    We have reimplemented the entire Haskell standard list library on top of our framework, providing stream fusion for Haskell lists. By allowing a wider range of functions to fuse, we see an increase in the number of occurrences of fusion in typical Haskell programs. We present benchmarks documenting time and space improvements.

    Vala is a language inspired by C# which does not allow null reference types without explictly idenitfying them as nullable.

     

    eg:

     

    string foo()
    {
       return null;
    }
    
       

     

    won't compile

     

    string? foo()
    {
       return null;
    }
    
       

     

    would.

     

    This will alert the caller on the possibility that function can return null, and thus the programmer can take the needed precautions.

     

    C# could use similar syntax. Hopefully one day we can get rid of NullReferenceExceptions for good. They do not belong in an managed language IMO.

  • Ideas for C# 5.0

    exoteric said:
    Bass said:
    *snip*

    It's the same with mutable vs immutable - we're finding that the defaults are wrong

     

    - mutable vs immutable by default

    - nullable vs unnullable by default

    - imperative vs declarative by default

     

    really, all these choices steer you toward the functional paradigm but not necessarily without object-orientation (Scala, and less so, F#)

     

    but it's actually not too late to reverse the situation in C# - consider this

     

    val x = 3; // immutable by default - type-inferred; doesn't imply out-lawing "var" but does begin a movement towards a saner default (well, actually, within a single method, if side-effects are constrained to it, supposedly it doesn't matter for purity; still, val would be nice; and this doesn't mean transitively immutable - each type would still need to be implemented as immutable)

     

    immutable unnullable class Person ... // self-evident, if bloated - but bloat at definition site is better than bloat at use site

     

    or -

     

    invariant class Person ... // as above

     

    or -

     

    immutable class Person! ... // as above

     

    Strip away some paths of expression (implicit nullability, implicit mutability, implicit side-effects) and you give the compiler greater (or at least easier access to) freedom to do radical program transformation. I'd like to think that's where we're going...

     

    One thing is reversing the present. Another is reversing the (sins of the) past - also known as the .Net Framework... But that reversal probably begins with a more principled C#.

    Is there any actual compilers against functional language that can do analytical optimizations?

  • Ideas for C# 5.0

    exoteric said:
    vesuvius said:
    *snip*

    I'm quite curious as to how you'd create a more efficient representation than a struct wrapping a reference type, please elaborate.

     

    Actually this is not about performance at all, it is about correctness.

     

    I'm not very familiar with Spec# but believe it has syntax support for non-nullability. Does Spec# not use the off-the-shelf CLR?

     

    As to extension methods, that's a different thread, this is about C# 5.0 ideas (but would welcome any discussion about anti-patterns there; I don't think Contract makes sense as an extension method cluster at all; it does make sense, however, to lift the methods out to be accessible without name qualification; MessageBox.Show, I don't know about that one; - but let's have that discussion in the other thread).

    I like your idea. I'd extend it to say I think .NET should have used non-nullable types by default. But it's probably too late for that. Sad

  • Why no USB monitors?

    MTROVER said:

    USB Monitors, where the graphics data is sent via USB, have existed for 3 years now.  Samsung sell the LD220 22 inch USB Graphics monitor.  This device uses the DisplayLink technology to product HD video performance over USB.  Also 6 of these monitors can be connected to a single USB port, via a hub, to add a hugh amount a new Desktop workspace.  Please look at the link below for details.

    http://www.displaylink.com/shop/index.php?product=2

     

    With USB3 coming out it might be possible to transmit HD video losslessly through a USB cable. Add Add

  • Why no USB monitors?

    MTROVER said:

    USB Monitors, where the graphics data is sent via USB, have existed for 3 years now.  Samsung sell the LD220 22 inch USB Graphics monitor.  This device uses the DisplayLink technology to product HD video performance over USB.  Also 6 of these monitors can be connected to a single USB port, via a hub, to add a hugh amount a new Desktop workspace.  Please look at the link below for details.

    http://www.displaylink.com/shop/index.php?product=2

     

    With USB3 coming out it might be possible to transmit HD video losslessly through a USB cable 

  • Ideas for C# 5.0

    TommyCarlier said:
    Bass said:
    *snip*

    var i = 123L; // the type of i is long/Int64

    I ment to say that the compiler can figure out if a literal should be an Int32 or Int64 based on it's size. My bad.

  • Ideas for C# 5.0

    staceyw said:
    Bass said:
    *snip*

    Not sure that would make the cut without a suffix literal.  But something like a "B" suffix would seem to fit.

    There is no suffix literal for Int32 and Int64, try doing a var on a literal over 3 billion in value, the compiler will automatically define it as an Int64.

  • Ideas for C# 5.0

    exoteric said:

    I'll start out -

     

    Tuple Syntax 
    a la (precise parenthesization not so important here)

    (1,2,3)

    Tuple Enumeration

    Not a language feature but allow tuple to be enumerated (IEnumerable<T>) for both homogeneous and heterogeneous tuples, meaning these two cases would both be legal

    foreach (var x in (1,2,3))
      Console.WriteLine(x);
    foreach (var x in (1,"WTF",3))
      Console.WriteLine(x);

    Where in the first case the tuple would be IEnumerable<int> and in the second case the tuple would be either IEnumerable<IDynamic> or IEnumerable<Object>.

    BigInt literals

     

    var bigint = 349438474346346348348346734634634892390139328234746546348349349347237236465483932948565623893832932932737;