You are currently browsing the category archive for the ‘Uncategorized’ category.

Finished watching recording of his talk at “Business of Software 2009” conference.

 

Very entertaining and got me thinking…

Simplicity has it’s place. But when users are demanding more (advanced features) you have to offer it.

… Keeping complexity under control and hiding it after an elegant facade  – that is a true art of software development. And don’t forget user’s requirements…

Before even trying to explain to somebody what Castle Windsor container does be sure that other side understands the Dependency Injection principle – why it is important and what you’re achieving by using it.

It’s important

And after explaining DI, if you have some time, pass quickly trough SOLID

In technology, once you have bad programmers, you’re doomed. I can’t think of an instance where a company has sunk into technical mediocrity and recovered. Good programmers want to work with other good programmers. So once the quality of programmers at your company starts to drop, you enter a death spiral from which there is no recovery.

By Paul Graham, What Happened to Yahoo.

I know, it’s late, but this…

FatalExecutionEngineError was detected
Message: The runtime has encountered a fatal error. The address of the error was at 0xf8b96934, on thread 0x147c. The error code is 0xc0000005. This error may be a bug in the CLR or in the unsafe or non-verifiable portions of user code. Common sources of this bug include user marshaling errors for COM-interop or PInvoke, which may corrupt the stack.

Is it the way how CLR is saying “time to go home”?

Udi Dahan has written about an interesting way to evolve loosely-coupled application. It’s a very interesting trick and we’re already using it in our applications. And we’re using it for a very similar scenario: allowing to application modules and infrastructure to step in and say what they have about configuration and bootstrapping.

For example, some modules can modify configuration of NHibernate’s SessionFactory. We have next interface:

public interface IConfigurationContributor
{
    void Process(string name, Configuration config);
}

And whoever wants to intervene in configuration of any SessionFactory is implementing it. When factory is build container is pulling all implementors of IConfigurationContributor and “runs” over all of them.

As a result – clean design and loosely coupled application parts…

Watched presentation of Dan Norman at “Business of Software 2009” conference. Really enjoyed the talk.

From my understanding, it’s about keeping in mind human experience when working on software products and never stop thinking about your customers/users as a real people: they make mistakes, have emotions and take decisions based on previous real world experience…

Had to install from zero a Dell notebook recently. Yes, my new development rig… Apart of Windows installation experience (very simplistic in essence & straightforward) had to install latest drivers for all notebook’s hardware. Typically, process looked like this:

  • go to Dell’s site
  • look up the latest driver for device you want
  • download it
  • run it – it’s a “.exe” file.
  • done!

And today I want to update device drivers for my older netbook: Asus 1000H. I wanted to start with updating the BIOS.

  • Got to Asus support site,
  • found the latest BIOS version
  • downloaded it
  • it’s a “.rom” file.
  • full stop!

Guess then, which portable device I’ll buy next? Definitely, not an Asus.

Got in mind the “Don’t make me think” by Steven Krug…

PS. It’s always small touches and details that makes the experience polarized: love/hate is one detail away…

I have new monitor: Dell UltraSharp 2209WA.

What I like:

  • Slick design. Breathes style and functionality.
  • Panel: IPS. Crisp visual elements. Wonderful colors.
  • Functionality: adjustable height, portrait mode, USB hubs.
  • Brightness is set to 12% and it’s well enough.

Working on wide angles and big resolution will need a bit of accommodation and changing some habits.

It looks nice, image quality is top. I think I’ll be loving it…

Recently, in my desire to learn something new and get closer to local community of software developers, I have visited few meetings of Java User Group in Lausanne. You may ask, what can attract a .NET developer in Java community? For me it was mainly the themes what were discussed. First one I’ve attended was about Groovy and Grails – new dynamic language and a framework that are running on JVM. The second was a nice session about Scala – static, OO programming language that also integrates nicely some features from functional programming world.

So, sessions I’ve attended wasn’t really about Java, but about new programming languages. I’ve read somewhere, that in order to be a better programmer you have to learn a new language every year. Well, honestly, I’m not sure that I’d be able to learn new language that doesn’t fits in my tool belt and it’s not used daily. So, I’ve considered that the least I can do is familiarize, even superficially, with new programming languages and concepts.

I enjoyed very much both presentations.

I’m not sold over dynamic languages yet. I’m not sure it will work in a big, “enterprisey” project. But may be it’s because I don’t have any experience using it.

But I liked very much some concepts from Scala – mixins, traits and few other things are just mind blowing! The language is very clean and concise.

But, even without some of these features backed in .NET/C#, I think that development platform from Microsoft offers more for an “average” software developer. Productivity, tooling support, training. It’s only because MS has more resources to do it…

… and his “clever” UI:

The error is that control interfaces must not be intelligent. Briefly, intelligent user interfaces should be limited to applications in which the user does not expect to control the behavior of the product. If the product is used as a tool, its interface should be as unintelligent as possible. Stupid is predictable; predictable is learnable; learnable is usable.

Continue reading: Wolfram Alpha and hubristic user interfaces.