TEACHING: Study club of MUGI Jadetabek on Developer Track, WEEK 3

It’s week 3 now! Time for MUGI participation! Now MUGI Jadetabek has initiated study club. Initially we have two tracks: developer track and infrastructure track.

Initially started as an idea from Abdullah Muhammad (chairman of MUGI Jadetabek) and I when attending Microsoft Community Summit, now it becomes realization. The place is at Microsoft Indonesia’s main office, JSX on 18th floor.

The course will be in the form of 5 times informal meeting weekly.

For developer track, we have 5 attendees. We have decided to limit the number of attendees for now, as we want to spread and teach the knowledge effectively.

Initial developer track will be delivered by myself, Eriawan. As for now, I deliver introduction to C#.

---

Week 3 is on 8th November, still at the same Microsoft Indonesia’s HQ at BEJ Jakarta.

Now, the subject is about advanced OOP and collections in .NET (including generics).

This week we only have 2 attendances because Wakhid was taking care of his final paper assignment and Aris was sick.

I had demo on LINQ Select:

As always, the show must go on!

We moved to smaller rooms but I think it’s good, because it separated from the Infrastructure track that begins on developer’s week 3!

I gave home assignments to create implementations of ICollection<T> and also create WHERE method of LINQ.

As promised, the slide deck will be uploaded soon. I hope tomorrow I can download the slide gracefully as it’s quite large, more than 6MB!

The next week 4 will be scheduled on 23rd November. Stay tuned!

TEACHING: Study club of MUGI Jadetabek on Developer Track, WEEK 2

For developer track, we have 5 attendees. We have decided to limit the number of attendees for now, as we want to spread and teach the knowledge effectively.

Initial developer track will be delivered by myself, Eriawan. As for now, I deliver introduction to C#.

Hi there! This is Week 2 of Developer track study club, part of MUGI Jadetabek community program. As usual, we held this on Microsoft Indonesia office, on 2nd November, 2013.

This week I bring OOP concept in C# and the OOP.

---

Official link for OOP in C# and VB (for Visual Studio 2012) is at: http://msdn.microsoft.com/en-us/library/dd460654%28v=vs.110%29.aspx

Before that, we spent 1 hour to discuss last week homework task: creating butterfly.

These are the pictures from Week 2:

 

And this is another style pose:

Basically, OOP has these 3 pillars:

1. Inheritance
2. Polymorphism
3. Encapsulation

Unfortunately, OOP was not described well in MSDN Library.

I suggest we look at the Oracle’s Java documentation of OOP at: http://docs.oracle.com/javase/tutorial/java/concepts/

They have nice illustration to describe encapsulation:

And the sample in real world:

The slide will be available on week 3, tomorrow!

RX Communica SDLC Journal: Feature Points

Hello there! I’m now writing about SDLC in the form of journal.

The journal will contain my quick insight and ideas taken from best practices, and it also contains my company’s (RX Communica) shared perspective and practices. RX Communica is my own hybrid of non-profit and profit company.

This journal doesn’t have to be in order of learning sequence, not like my F# adventure series. Enjoy!

---

Now I’ll discuss feature point!

Feature point is a weighted score, and it should be based on how much the feature is anticipated based on "MUST HAVE" of Moscow method. It can also have psychological cost, in a sense of the importance of the feature.

At first creation, a feature will have either zero or positive point, but as the feature is used, it can also have negative point.

User feedback, especially when it's focused on a feature will be counted as a weighted score point.

These are the sample use cases and reasonings:

• If there's many negative point for this feature and if this feature is the base foundation for all other feature, then this feature needs to be prioritized to have attention, but it doesn't have to be integrated first. The attention is very critical, that it may lead to feature detach (abandon) or recreate the feature with different logic and refined functional spec and technical requirements. In my previous experience, the integration of this feature can be deferred for next minor or major release, depends on the criticalness.
• The feature that has many negative points should be considered as technical debt that has to be paid soon, as a debt has to be paid in order to decrease critical back log of feature defect that wasn't good thought at the beginning.
• If there's a new feature as the evolution consequence from this feature, then the new feature request based on this one should be rejected or we can investigate further and communicate to the stakeholder that this feature is based on current feature's negative points and it will add more negative points.
  This can lead to further democratization of how we provide the servicing of feedbacks from stakeholder, as if the positive feedbacks don't outweight the negative feedback, we can safely weighing more and leaning more on positive feedback as the source of prioritization consideration. This technique often called "crowdsourcing" but only in scope for software development.
• If the feature has many positive points and also has positive feedback points, then this feature can accept future enhancements.
• The feature (or can be features) that meets our coding and high reliability standard on extensibility (including the notion of Open-Closed principle from SOLID principle) has to be integrated first because it's easier to integrate with high confidence. This feature is therefore have high positive feature points.
• By keeping these green field and feature point concept from start, we will not be trapped easily into brown field model and complexity (smile)

This is to illustrate the fate of a feature in feature points perspective:

If you read the Code Complete 2nd Edition book, the feature point can be used to prioritize integration between features. Feature dependencies should be taken into account first, provided that you have dependency documentation available clearly. If there’s no documentation, then there’s a large possibility that the the software project will fail in the middle of development, test, or even when used in live production.

There’s a video from Channel 9 MSDN website that quickly describe feature point in action. This video is about the introduction to C# 4 design team, but it’s very worthy to watch.

Here’s the link: http://channel9.msdn.com/Blogs/Charles/C-40-Meet-the-Design-Team

NOTE: the feature points not to be confused with feature point matrix of function points.

---

Further references

1. Code Complete 2nd Edition for online reading (if you have Safari account): http://techbus.safaribooksonline.com/book/software-engineering-and-development/0735619670
2. Code Complete 2nd Edition book to buy at Amazon: http://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670/
3. Function points for measuring algorithm, inputs, outputs complexities: http://www.spr.com/feature-points.html
4. MosCow method: http://en.wikipedia.org/wiki/MoSCoW_Method
5. Crowdsourcing: http://en.wikipedia.org/wiki/Crowdsourcing

TEACHING: Study club of MUGI Jadetabek on Developer Track, WEEK 1

Time for MUGI participation! Now MUGI Jadetabek has initiated study club. Initially we have two tracks: developer track and infrastructure track.

Initially started as an idea from Abdullah Muhammad (chairman of MUGI Jadetabek) and I when attending Microsoft Community Summit, now it becomes realization. The place is at Microsoft Indonesia’s main office, JSX on 18th floor.

The course will be in the form of 5 times informal meeting weekly.

For developer track, we have 5 attendees. We have decided to limit the number of attendees for now, as we want to spread and teach the knowledge effectively.

Initial developer track will be delivered by myself, Eriawan. As for now, I deliver introduction to C#.

---

This is the picture from Week 1 on 26th October, 2013:

Above, Abdullah was delivering welcome speech.

I start this week with these discussions:

1. Quick intro to Visual Studio 2012
2. Installing offline documentation of Visual Studio 2012
3. Creating Visual Studio C# project
4. Basic primitive type of C#
5. Looping (for and foreach)

The topics above was adjusted with the current knowledge and current understanding of the audiences. This is why some of the topics are very basic.

In this week, I gave them homework task to display butterfly using “*” and spaces.

The slides will be ready after week 3, based on the evaluation for 2 weeks of participation, guys!

The next week: Fundamentals of OOP!

Interested? Ask Abdullah Muhammad, or visit MUGI Jadetabek on Facebook!

Visual Studio 2013 has been released

Hi my blog audiences!

Yes, you’re right! It’s not a typo! Visual Studio 2013 has been released and available to download!

Just go to: http://www.microsoft.com/visualstudio/eng/products/2013-editions

This is the original announcement by Somasegar in his blog: http://blogs.msdn.com/b/somasegar/archive/2013/10/17/visual-studio-2013-available-for-download.aspx

What’s new in Visual Studio 2013: http://www.microsoft.com/visualstudio/eng/visual-studio-2013

The editions of Visual Studio 2013 are the same as Visual Studio 2012:

1. Express
2. Test Professional
3. Professional
4. Premium
5. Ultimate

For those new to Visual Studio, I suggest starts using Visual Studio 2013 Express Edition.

Here’s the link: http://www.microsoft.com/visualstudio/eng/downloads#d-2013-express

Now, everything is getting more interesting in Visual Studio world! Visual Studio will have shorter cadence release! This is also a perfect sample of Application Lifecycle Management discipline clearly implemented!

The picture was from a slide deck of Brian Harry, MS Technical Fellow, when delivering presentation on TechEd North America 2013.

This means, every 11 to 13 months a new Visual Studio version will always be available.

Implementations of Memoization in F#

Today let’s talk about memoization.

This is the definition of memoization in Wikipedia:

“memoization is an optimization technique used primarily to speed up computer programs by having function calls avoid repeating the calculation of results for previously processed inputs.”

To put it simple, memoization is a technique by remembering the previous result of the function results. This implies that memoization is best to use as recursive functions, because it needs to call itself again!

The need to store values means that it needs mechanism to store result value.

To implement this mechanism, of course we need another helper variable to store the result.

Don Syme, the original creator of F# has this simple sample of memoization on his blog.

Here’s his starting sample:

There’s no further explanation about how the code above works. We’ll try to dive it together.

In his first sample, type checking on x (as x in the “fun x –>”) will always be performed.

He used System.Collections.Generic.Dictionary of <_,_> to map x as the key and fill the value with the result of computation of f x.

This is the power of type inference in action, so we can expressively map Dictionary<_,_> to have two kinds of generic type without naming it.

F# then will infer the first “_” as the key, and the second “_” as the type of the value.

The signature of “memoize f” is “('a -> 'b) -> ('a -> 'b)”.

The Dictionary used then will be used as a cache to store result value.

He further update the memoization sample.

This is the update using unchecked type:

And now using single mutable reference of Map:

The code above is more functional because it uses immutable F# Map instead of mutable System.Collections.Generic.Dictionary and also easier to understand, though using Unchecked is cleaner in some sense of C# perspective.

Another reasons to use F#: Why use F#

Wow! I really missed this gem!

There is a website dedicated for explaining why using F# is fun and also profitable.

The link is: http://fsharpforfunandprofit.com/why-use-fsharp/ and it’s very informational!

There you can find a series of 30 parts of defining “Why use F#” in a very short but concise.

The main reasons of Why use F# are:

• Conciseness
• Convenience
• Correctness
• Concurrency
• Completeness

The nice additional feature is, they have syntax highlight!

Definitely one of the best F# resource to keep!