The initial aspect of the camera and how to use it is on the previous post on cameras, so I ll let you go and have a look there.

The spring camera is very similar to a simple camera, but with Hooke’s Law applied. Hooke’s Law states that the extension of a helical spring is directly proportional to the weight applied, provided the elastic limit of the spring is not exceeded. I read this a few times and couldnt figure how to turn this into code , so I went to Khan Academy and found this video, where the formula F = –k x is explained.

If we use the formula as is, then the spring would be “springing” forever, so when calculating the force we will use some damping. So the new update method in Camera.cs now looks like this

 1: public void Update(float elapsedSeconds, float rotation, Vector2 desiredPosition, float zoom)

 2:     {

 3:         var delta = _position - desiredPosition;

 4:         var force = -SpringStiffness * delta - Damping * _velocity;

 5:

 6:         var acceleration = force / Mass;

 7:         _velocity += acceleration * elapsedSeconds;

 8:         _position += _velocity * elapsedSeconds;

 9:

 10:         Transform = Matrix.CreateTranslation(-_position.X, -_position.Y, 0) *

 11:                     Matrix.CreateRotationZ(rotation) *

 12:                     Matrix.CreateScale(zoom, zoom, 1)*

 13:                     Matrix.CreateTranslation(_halfScreenSize.X, _halfScreenSize.Y, 0);

 14:     }

The line

var force = -SpringStiffness * delta – Damping * _velocity;

Is respecting the formula F= –kx, where k is the SpringStiffness and x is the delta(in orange). The second part of this assignment(in green)  is applying some damping proportional to the velocity.

Once we have the result of calculating the force, we use the force vector to calculate the acceleration that, in turn that value is used to calculate the velocity and position.

Finally, once we have the position, the matrix transformation is calculated in the same way we calculated this for the simple camera (in previous post).

You can get a complete working sample here.

NOTE: I have an android phone, and had an iPhone for a while in the past, so my expectations about this phone are probably based on them.

As soon as I connected the phone to my computer it prompted me to install the Zune software, after installation you get this:

restarting my machine? we are not in 1999, this shouldn’t be a requirement.

Also when I was trying to install some game, the phone displayed a message about the fact that some installations require re starting the phone. Very strange

Rather randomly on an LG –E90099 I get the error that the phone is pin locked (it isn’t ).

If while trying to debug to your phone you get an error, “The application could not be lauched for debugging. Verify that the application is installed on target device” that, for me , meant that the phone was locked (ie dark screen) Make sure you can see the menu and try again

After these initial errors, I pretty much moved pretty quickly.

I  am quite surprised by this, but at least for game development  (with xna) this little trial has been incredibly painless.

Regarding the phone OS,  there are some aspects that I really dislike:

• A lot of screen is wasted, for example if i search online for something, I can only see about 2 to 3 results.
• The facebook integration (I dont want facebook). Probably it can be turned off?
• Figuring out how to un-link the hotmail account to the phone is quite tricky (it might be just me)
• Having to restart your phone after installing an app is just not acceptable.

Things I liked about the phone

• Dealing with text in general is superior at least to the android experience. ie writting texts and email was a good experience
• Generally fast and non cluttered

In general my perception of the phone has improved after trying it . And I have to add I m pretty impressed by the Zune software, it looks good, it worked flawlessly. Comparing to iTunes and Samsung Kies it’s way ahead.

I like XNA, and the fact that it was so transparent to deploy a game to the phone was really nice.

Tips for scientists writing code (1st Round):

• Talk to other scientists that work on similar projects and share a list of your most used functions (I cant remember the name of the person suggestion
• Every now and then meet up with other scientist writing similar code to you to talk specifically about the code you write, after all if you know the tools you are working with better, you are bound to be more productive
• Use source control. There are pretty good open source alternatives and many places that offer free storage. Some source control options: Git, Mercurial, subversion. Some places to host your code: github, bitbucket, google code, codeplex
• Use variable names that indicate what you are talking about.
• Some bad examples: your_cat_name, sss, ttt, etc. Some good examples: portionOfSphere, portion_of_sphere.
• In the case of IDL, avoid for loops and try to use functions
• Try to get used to reading others people code so that you realise where you can improve, or point out things that can be done i na more effective way

 Help a scientist day

The above is all well and good, however. We were also thinking about collaboration. So Philippe came up with a great idea: Help a scientist day.

• A scientist submits (somewhere to be discussed) a problem she or he thinks it could be solved with some help of more developers
• people can ask questions about the idea (either technical details or just to check that its a problem similar to theirs)
• People can vote on ideas (no need to sign up )
• The ideas with most votes (that are doable) will be the ones that will be implemented by developer during “Help a Scientist Day”

So, we need to organize this day, please comment on G+ so we can get this going

Cheers

• XNA getting started tutorial. Well organized, paced  series of  XNA tutorials by a guy that teaches this. If you know nothing this is pretty good.
• Xna workshop. Some posts and links to learn XNA Is kinda handy to see other people’s questions
• Riemers XNA Tutorials. I think this is a link you want to keep, every time I search for something XNA related I get a post from this guy
• 2D Camera with parallax scrolling. Does what it said on the tin, very comprehensive article that also links to other interesting articles.
• Mono game. The good news is that there is a port … “MonoGame is an open source implementation of the XNA APIs that allows developers to build 2D games that run on Android, iPhone, iPad, Mac, Linux and Windows using the same code base, or reusing existing XNA code that runs on Xbox 360 or Windows Phone 7″

If you know of other good details, please comment

Continuous Integration:

• Team City: I use it and really like it, simple to set up and use, if you want to try it they have a free professional edition .
• Cruise Control.net: Open source, used it but didnt find it too friendly, I m aware a lot of people use it
• Hudson. Originally a Java only project but there are some success stories on the .net fence, has some features unavailable in the other two mentioned above.
• there must be something else. ?

• StoryQ:  This is what I use. Like it because you write C# code with some constraints and it generates reports on the behaviour. Samples: code report
• Cukes/Cucumber: I remember the first time I saw cucumber in action I was really impressed, however it’s hard to get buy in for a tool that requires another language installed, probably fine for some projects, it depends a lot on the project, the company and the culture.
• SpecFlow:  you write features in Gherkin(the cucumber spec language) that are then compiled into c# code. Nice reports, but I find the generated code hard to read… ie a bit too verbose (example feature example generated code) however I wouldnt discard it totally.
• NSpec:  You write c# code (very lambda-y)  and it generates reports.. like it even less for reasons similar to the above,  have a look at it yourself here
• Fit/fitnesse:  I haven’t tried it, it supposed to be very good, I ll leave that one to you (would love some feedback on this if anyone reading did try it)

Unit Testing Frameworks.

• xUnit: a nice, compact unit test framework, I like it because it has less noise,  no setup method (ie it uses the ctor for
• nUnit:  The most popular one.
• mbUnit: good support for RowTests.
• _
• msTests: the option by Microsoft. I tried this framework when it came out, so perhaps not valid anymore. My experience with it was that the same set of test ran 20% slower. Also it had poor support for theory tests. Maybe this all changed. I will guess that anyone using this framework does it because they can’t use anything else

Builds

• Psake:  powershel based DSL for building
• Rake:  Ruby based Dsl for builds, nice to use ruby, but sometimes needing the ruby dependency is a deal breaker
• Nant: not something I would choose, but hey if you like xml this is the way to go (if you like Xml you might want to talk to your doctor too )
• MSBuild:  I find it non intuitive, I thought I was being unfair so I asked in twitter what ppl thought of it. One supporter and 4 not really happy with it (see below)
• Final Builder : a commercial option, and not a bad one to be honest. Very easy to use (drag drop style) tho not as flexible as we needed.

I  apologize for the amount of lolcalts that I added to my presentation (available below) and any feedback, etc more than welcome.

In many ways it was good to get the presentation out of the way early  because it meant I could focus on being out there listening to other folks smarter than me talk and meet some people.

After my talk I was at Gary Short’s presentation on hoe to measure performance, interesting and really well delivered. Some interesting questions too.

Then I was at Seb Rose talk on TDD and unit testing. It was interesting to see that you can test drive a C++ app. His advice was sound. He talked about the importance of setting a structure before starting to test. He talked about the importance of deployment. And how it was important that the tests were also clean and well designed. Link to his slides

After that there was lunch, unfortunately (or not)  I couldnt catch any of the grok talks as I was talking to people, one of the ideas we had was to open source a project (not mine :S) that would make using selenium+qunit on CI easier… will see how that goes.

After that I joined a talk by Toby Henderson,  The dark parts of Mono. I reallly enoyed this talk. Info about small standalone tools or libraries that you can use, with examples. Such as IKVM, Cecil, SIMD, Compiler and Gendarme.

Finally, I joined the “Ask the Speakers” panel, very relaxed and quite fun. We talked about the news (Mono and its future, other stuff I cant remember – please comment),  innovation and community. There is a post of note that goes into some of the stuff we talked about .

All in all a great event, thanks to everyone for making it possible.

Recently a group of us (tho mostly Pablo Nuñez ) translated the article from Udi Dahan Clarifying CQRS. Here is the link to it, if you feel that it can be improved please just leave a comment here and I can add you to the document with edit rights. Some terms where hard to translate.

Thanks to Pablo, Carlos Peix , Jorge Gamba and everyone that retweeted and helped.

———-

Hola:

Me pareció que el articulo de Udi Dahan, Clarifying CQRS, podría ser muy útil para la comunidad de desarrolladores hispano hablantes.

Así que algunos de nosotros decidimos traducirlo, aquí esta  el link , la mayoríadel credito debe ir a Pablo Nuñez . Pero también gracias a las demás personas que ayudaron: Carlos Peix , Jorge Gamba , etc (la verdad no me acuerdo quien mas perdón:) )

Si tienes algún comentario o corrección simplemente deja un mensaje aquí y te puedo agregar al documento con derecho de escritura.

Gracias

I think the implementation of the patterns CQRS and ES is not trivial (it’s also not necessary to do both , but lets keep going) however, the escence of the advantages you get out of both comes from implementing the rules of the domain, in the domain. By making the state transitions explicit.

The number one reason why you should learn about CQRS without a framework is because, it could cloud your understanding of the domain with artificial constraints. Another important reason is that when you learn by doing, you understand the workings and shortcomings of a particular methodology.

That is not to say that frameworks are bad and you should never use them, but make sure that when you make a decision like that, it is a conscious one.

I remember one day when I was at a talk by Gregg Young, and he said: How many of you use (ms)SQL? How many of you made that conscious choice? (ie to use an relational database for storage) .  I realised then that, I didn’t make that choice or considered an option in certain cases, but what scared me the most is that I was making a bunch of assumptions as soon as anyone said “system” , it made me realise that most of those assumptions could blind me into not really considering all the options.

I would normally post here my presentation, but not sure its of any value, as it doesnt have much info, I use it for helping me remember what to say, if anyone want it, i can definetly post it, just add a comment here.

The code I was showing is a fork of  Super Simple CQRS code example by Gregg Young

I have a link (bit.ly bundle) with a bunch of links about CQRS and ES, including a few other sample code bases  http://bit.ly/9LC877

If you have any questions, or feedback good or bad (something missing?) please let me know by posting a comment here (if you don’t want me to publish it just say so )

Thanks for coming

Anyway, since I haven’t been able to the last two meet ups, I thought I’d do a second read of the Scala chapter and put together some notes. Please note I m writing the notes as I read.

- Scala is a hybrid language (a mix of OO and functional)
- Hints that its a different kind of language
- Runs on the JVM, though given the state of Java, not sure that is any kind of insurance. Scala can use Java libraries natively, just like Iron* languages , can use .net libraries directly
- Statically typed
- type inference (like c#? –> review)
- functional concepts, like c#? it would be awesome if it added some native support for immutable types
- Support immutable types, but its got some modifier ( need to check this out more in depth)
- actors

Scala is a general purpose language, interesting that it seems to fit well many scenarios because of this OO, Functional mix
Type inference seems to be not so strong
Principles of functional programming that apply to Scala:
- programs are made of functions
- functions return a value
- given the same input, a function will return the same output
- side effect free

val is immutable var not …. Likes

There is a full page on the book dedicated to somewhat clarifying strong vs weak and static vs dynamic  languages. I mostly agree with his points there.

My first impression when seeing the language was that it reminded me more to python than to java, maybe it was def .

• Visibility of methods, functions. Public is default
• Support for tuples and ranges . In purely functional languages, tuples are used as objects. You can do multi value assignment with tuples
• Constructors. I like Scala’s  syntax and default
• Object instances are interesting, at first I was thinking they were like static classes in C#, but apparently not quite. As far as I understand, an object declaration in Scala is basically a singleton instance of a class definition.  However, in C# a static class is a class that can be accessed and used, without creating an instance. That makes me think that there is a cost associated with the instantiation, but I cant see any other difference. (comments on this would be appreciated)
• traits. Like an interface and an implementation all in one, generally focusing on a single concern, well that’s what the book say, however I can’t see here how you do to declare a trait separetly

As Part of the exercise of Day 1 you need to find a comparison between Java and Scala(I found this), one of the interesting things I learned while checking that out is that XML is supported natively, I also liked the point on moving to a more functional style of programming slowly, but with a nicer syntax.