Meta Steps, YMMV…
1/Select what you need from Spring INITIALIZR :: https://start.spring.io/
2/Download/Extract the zip && cd into it.
3/Create a git repo on xp-dev.com
4/Initialize Git repo:
b)git add .
d)git commit .
e)git remote add origin https://xp-dev.com/git/
f)git push -u origin master
a) checkout https://xp-dev.com/git/
b) Goto Maven Projects and add the pom.xml(if not picked automagically by IntelliJ
c)Do deploy, I got a failing unit test, as I added spring-tests.
Couple of days back at work, I got my first opportunity to document the requirements for a particular moderation flow.As a practice we document everything in microsoft project management tool(read: ms word).
And the pain of tracking the changes, without review/comments is unacceptable!
Hence with the motivation set in, this is the template that I could come up after a *lot* of thinking:
||I want to do …
||My action affects…
and here’s an instance of an entry derived from that template:
||See new artefacts entered by users
||I can validate the contents.
||There are new artefacts available in the system.
||Displaying the artefacts with ability to go to next artefact and/or approve/disapprove them.
I have modified the actual text that was prepared for generality and not keeping office work in public!
Incase you have not already guessed, this instance deals with viewing artefacts for moderation.
While preparing this template, I was not cent percent aware of the domain that I was dealing with and also, I was new to this module, maybe that can work in favour of most people in similar situation!
What do you think? Does this template gives you the ability to cover all/most scenarios in your development story?
The extreme programming wave initiated by Kent Beck et al in 1999 and since then the mature world programmers have embraced that change. A lot many clones started from that movement like agile itself, and the much widespread like scrum and lean.
Although these methodologies(or approaches?) had existed since long time, I remember reading somewhere that motorola had these practices in place since the 1960’s.
Flash-forward to India, I do not know who or when was the first project here was done with the wisdom of sound agile practices? But since I stepped into the professional way of writing software(means I was paid for what ever I did or did not), I was fortunate to see a genuine mix of these practices from the very start.Moving on to different software vendors, I notice that India per say is yet to embrace agile in spirit.
I do not travel at all, but looking around the small sample of professionals(incl self claimed agilist’s) I am dis-heartened to say the least, when I see my self surrounded by a lot of certified SCrUM(pun intended).
No doubt it has made its mark and helped realize XP too, ever since I got to know about XP, I had(still do) predicted the end of the software manager(with MBA) as a career.
The point that I want to make across is that these managers have misused the insights from agile practices to abuse the Indian developer. I have seen(and heard) *only* Indian managers who have been doing this to their Indian counterparts.
I dare say if they are given a mix of developers from different geographies, they would not do the mistake of exploiting more work in lesser time.
That is like a blind person blessed with more powers.
That being the problem around how do I( or we?) as the Indian developer in the clutches of the Manager (with MBA) cope with it?
Ahh! Its a complex mix out there.There are managers without MBA also.
Need to get back to the drawing board and start afresh!
Writing unit tests for working on a piece of code is an exciting task that I enjoy.
To accomplish this with ease, for now my junit arsenal has the following approach:
1/ Mathematical Induction
2/ Boundary Value Analysis
3/ Permutation of the variables.
Care to share?
Today while working at my desk, I came across a situation where a colleague was writing some piece of code as a missing implementation when a module changed hands.
There was little time and so, the part had to be just written for the sake of it.
And that’s where I wanted to dis-associate myself from the partnership.
It so happened that the situation was getting complex and two heads were good at solving it.
I could not yet overcome my hesitation to help in a piece of code that would not be tested, so rather than saying this, I called it the white code: The one that was written on the white background of eclipse editor and never get through living in the main memory and get executed!
To my happy surprise, he got motivated and understood my hesitation and ensuring the missing implementation code was atleast working on a non matching scenario and breathe life into the code.
There we called it the green code:Simply because it was executed, not for complete scenarios, but it was executed!
Green is the way to go!
For Model is optional/and possibly an impediment, unless asked for.
The following picture depicts my understanding of what piece of technology resides where when writing the code from a UI->Business->DB.
When doing TDD<->Code, there are very short and quick feedback cycles due to which there is good paced development.
When doing it with modeling involved as the short feedback cycles turns into a painstakingly long , and hence looses the pace that could have been achieved with no MDA at all.
Even with MDA as a choice, is it beneficial to extract technical details from the model or derive the model from the interface?
The interfaces act as the point of inflection of choosing whether to MDA or not.
I am not very much into Big-Upfront-Design camp,maybe due to lack of experience but as I understand every software solution in the writing has its own characteristics that are better dealt with when dealt with no big designs that over-shadow its actual requirement.
With features like reverse engineering from code-to-UML, although the cycle could be shortened, but only to load the design with something conceptual at a high level, even with a high probability that the same understanding could be useless or simply a cause of not being able to implement an elegant solution.
The fact that MDA is dependent on the interfaces to proceed and TDD creates those interfaces, not by thinking-out the complete system, but on a case-by-case basis, so the two approaches can exist, but in true agile spirit?
I don’t think so.