Judah Gabriel Himango

Back to Profile: Judah


  • The RiSE of Research in Software Engineering

    Great interview, Jonathan, you did an excellent job. Looking forward to more videos on Pex and Contracts!
  • Research: Contract Checking and Automated Test Generation with Pex

    After playing with the library for awhile, I think this has a lot of potentials.

    I'd like to give you guys some feedback as I considered how we would integrate this stuff into our codebase (that is, once contracts are under a commercial-friendly license!). Where do we send feedback?
  • Research: Contract Checking and Automated Test Generation with Pex

    Great stuff!

    I must admit I was saddened to hear Spec# wouldn't be integrated into C# 4. But this is the next best thing; I'm glad to see design-by-contract getting some attention in the .NET framework itself.

    If I may comment on the presentation, it feels like you both should have had your own presentations. It felt too rushed and too crammed.

    Having Mike go deeper into the evolution of Spec# and why they chose a library instead of C# langauge integration would've been great. And Nikolai covering more real-world unit testing scenarios with Pex - for example, testing code with dependencies like the file system or UI using Pex, would have been a great presentation by itself.

     Also, the rehearsed Q&A between Mike and Nikolai was cheesy. Too tongue-in-cheek! Smiley

    Beyond that, great stuff guys! I'm really happy to see DbC getting some real attention, I believe it will help us write code that more clearly expresses our intent and contains fewer bugs. That's something every developer can get behind. Going to go download and play with the VS2008-integration...

  • Modeling Through the Ages

    I loved the video guys, great job. Made Oslo a lot easier to understand. I much prefer this kind of lighthearted explanation than a marketing-speak filled video.
  • Parallel Computing Platform: Overview and Future Directions

    Charles, you said in the interview that parallelism is not a key concern for C# developers.


    Parallelism is huge, huge, huge for us. We've fought so many times with locks and deadlock problems and throughput in our code; we want better parallelism abstractions. I'd say it's #1 or #2 on my wishlist for C# vNext.

    Thanks for the interesting video!
  • Countdown to PDC2008: By Developers, for Developers: Don Box and Chris Anderson

    So, I was on the right track with the "chunks of 3" thing. Cool. But I wasn't able to solve it.

    Just finished talking to palotasb (Boldizsar) above who solved it. He posted a discussion of how he solved it at his blog.

    Wow. Nice solve. I'm blown away by his hacking skills. 15 year old, of all things!

    Congrats on the solve!
  • Countdown to PDC2008: By Developers, for Developers: Don Box and Chris Anderson

    Here are some interesting stats from the cipher they flashed on the screen:

    There are 708 characters in the cipher, excluding new line characters.

    Given a chunk size of 3 characters,
    • There are 236 chunks.

    • There are 172 duplicates.

    • All the characters are numbers between 2 and 9.

    • The 323 code shows up a whopping total of 29 times!

    • The 333 code shows up 11 times.

    • All other codes show up 7 times or less.

    • 35 chunks start with a 2.

    • 200 chunks start with a 3. (Interesting!)

    • 1 chunk starts with a 4.

    • Despite the cipher containing 2s, 3s, 4s, 5s, 6s, 7s, 8s, and 9s, chunks only start with 2 and 3, except the 1 chunk that starts with 4.

    • There are no 0s.

    • There are no 1s.

    • There are 115 2s.

    • There are 293 3s.

    • There are 56 4s.

    • There are 38 5s.

    • There are 49 6s.

    • There are 52 7s.

    • There are 63 8s.

    • There are 42 9s.

    The 323 code is very interesting indeed. I'm leaning towards chunk sizes of 3 being involved somehow. We'll see!
  • Countdown to PDC2008: By Developers, for Developers: Don Box and Chris Anderson

    Let's see if the geniuses at StackOverflow.com can help us out with the code deciphering. Smiley
  • Countdown to PDC2008: Pick Your Sessions, Build Your Agenda and Win a Trip

    While we all love giveaways, it appears to require PDC registration.

    I'd love to go to the PDC! But I don't have a few grand to blow. (Wife would kill me!)

    Microsoft, how about some giveaway trips to the PDC?
  • This Week on C9: Scott Hanselman and Charlie Eriksen in the house

    Great little show, guys, I love these.

    Scott, don't feel bad about trough. I've always pronounced it as "traw - th" Smiley
  • C# 4.0: Meet the Design Team

    Guys, for over a year now, I've been telling folks at Microsoft that what we want is language constructs that help you write less buggy code.

    It should be obvious, but this is the thing plaguing software teams; we write buggy code and we spend a lot of time writing unit tests, physically testing, debugging, and doing formal code reviews -- all in an attempt to get rid of bugs.

    C# 4 should add some constructs that help us write software with fewer bugs in it.

    For me, this means integrating some of the excellent research done over the last several years by the Spec# guys. The design-by-contract stuff would help us rid our codebase of mistakes developers often make when working on large, complex, real-world software systems.
  • Programming in the Age of Concurrency - Anders Hejlsberg and Joe Duffy: Concurrent Programming with

    Great video, Anders & Joe.

    Really looking forward to this!

    Some folks were asking whether PLinq and the ParallelFX library detects accessing shared state between thread and other naughty things. Perpahs Joe can confirm this, but I'm nearly certain it does not.

    Plinq is about allowing developers to easily parallelize queries.

    ParallelFx is about allowing developers to more easily parallelize common tasks.

    Neither, however, prevents you from creating threading issues by using shared mutable state between threads.

    The good news, however, is that by using LINQ, we're headed towards a more functional, declarative future. Those who have used functional languages like Haskell will know that concurrency is a breeze because of no or limited mutable state (e.g. all shared state is readonly, little or nothing has side-effects). As we move forward with Linq, I suspect C# programs will look more and more like functional programs, with less and less shared mutable state.