Helmes Summer Bootcamp 2017

Helmes Summer Bootcamp 2017

Tuesday 5 September 2017

Day 20

The final demo

The morning started out with laughter as we had already practiced our speech 5 times the repetition was already comical. As the Java team had won the coinflip they were to do the first presentation. We had a short introduction by Oliver and this was it, the teams had to present.

Late arrivals had to stand up

Java - Simple Access Manager - SAM

Java team started their presentation with a great catchphrase of "Today we're going to show you how to postpone spending 50,000 EUR by reducing unused licenses.". As they continued it was clear the demonstration had made leaps and bounds from the one we were able to see yesterday. But don't take my word for it. See for yourself :


.net - Contract and Invoice Registry System - CIR

After Java team completed their presentation it was my teams turn. Eva started her presentation clearly showing the value that our project provides and outlining the changes made. As she was finishing her presentation I could feel myself getting more and more nervous. And then it was my turn to present the demo. Thankfully we had taken Oliver's advice of "Practice, practice, practice!" and the script we had rehearsed took over.



After the presentations Oliver took the time to thank everyone involved(besides himself, Thank you Oliver!) in the event and gave a summary of what was achieved in the scope of the bootcamp. He ended his presentation with a gift to the team that was the best in this years bootcamp. Obviously we both got gifts, eveyone is a winner in bootcamp!

And then a pleasant surprise for us! We got a certificate that we had completed Helmes Summer Bootcamp and a book of our choosing! Considering on all 3 Sprint retros we had the code quality in the bad board then I think I chose correctly picking Clean Code.

Up next the head of development Raul Ennus gave the boocampers feedback, praising the presentations for not forgetting to highlight the value the teams created.
  
And to finish the morning demonstration the Java teams mentors demonstrated the progress of the Java teams progress using the wonderful tool Gource. This was a really nice visualization of the work they had done.

Was this it for bootcamp? Wouldn't be bootcamp without feedback. So after a small break we gathered around in a circle to discuss our feelings about bootcamp and the learning experience in general.

After another break we enjoyed a short lecture about using continous integration and continous delivery. This was something I felt we were missing as we had to copy our deployments manually.
And as the final thing in Helmes we gave feedback, in writing this time, about the people conducting the event.

The evening

In the evening we had a special dinner event where we ourselves would be cooking the food. We would be cooking portugese cuisine which had foods made from accessible and inexpensive ingredients for the main course and some more excotic fruits for the dessert.
Grabbing a plate

Discussing the bootcamp

It was a relaxing and casual evening and I think everyone enjoyed it. At the end of the dinner we split up as some of us went to old town to grab some drinks and some went home. Here's a joke dedicated to those who were true soldiers on our last day!
LEEROY JENKINS!

Some closing thoughts from my teammate Giorgi :This was the end of the bootcamp, One month of intensive work was over. It was obvious on our faces that we were full of emotions. Happy because we worked hard and achieved our goals, we became very good friends as a team, however sad because the bootcamp was over. We were thankful for the skills we have acquired. We have come to realize that being a part of a team is a lot more than just sharing credit. We learned that team effort takes compromise. But When you make it work it will top everything which was before. We learned that it’s not enough to be just a good “coder” there are many other criterias that you should satisfy and try to improve to achieve success in your career.

Thank you Helmes

I would like to thank everyone at Helmes who took their time to deal with the bootcampers. This was a huge task to take on 10 new people, give them a meaningful task and guide them while doing it. But you've done it. Amazing! I feel like this has given confidence and motivation to all of us to keep pursuing a career in IT and showed us the excitement that can happen in an IT project. 

To all of you considering applying for Helmes Summer Bootcamp I strongly advise you to take the time to do it. Already doing the technical assignment is great practice and it only gets better once you get into the bootcamp. I will be sure to reccomend this experience to everyone in a similar position. There is no such thing as too little experience or too much experience here, bootcamp covers the whole development process and offers insight from multiple points of intrest.

Sunday 27 August 2017

Day 19

The development of our system is over now. But there is still so many things to add :( Today we had our last sprint demo. Everyone was so confident in our success, that only we only had a few spectators. They were right, ours and Java teams demo was successful.
After the demo we had a video presentation seminar. During this seminar we discussed various ways to make our presentation better and more memorable. Everyone offered their thoughts and tips on what helped them, when giving a presentation and we were able to ask any questions about presenting. After completing this we were tasked with creating our final demo. While previously this final demo had been just a box to tick, this changed when Oliver said that this demo will have crucial impact on how we as a team will be remembered at Helmes. This meant the demo was suddenly very important and this brought a certain level of pressure with it. We didn't even know who would be presenting for our team.


In the end we decided that my teammate Eva will do the problem introduction and Giorgi will go through the application while I present. And by the time I had gotten my head around the fact that I would have to be presenting it was time for our video practice session. Java team went first and their presentation was roughly listing most of the features added to the system. As it turns out this was not the aim of the presentation at all. The aim of the presentation was to show what had changed in the process by adding this application to Helmes's tools. Leonid, the Java team presenter got a lot of feedback and then it was our turn. It went a little better as we did show the value that we created, but we were demonstrating the wrong part of the system. So for both teams it was back to the drawing board.
The next 3-4 hours we rewrote our presentations and reworked our demonstrations. The evening ended with us doing 2-3 practice runs to be ready for Friday mornings final demonstration.

Thursday 24 August 2017

Day 18

Our last days here. We're wrapping everything up and trying to finish off the stories we have left. During the stand-up we informed our PO, that we have a version on the test environment that is close to the final release for the sprint.

My task today was to load the data from our part of the system to the existing system using JavaScript. As I had started with that task yesterday and completed half of it already I was confident of finishing the task before 2 pm. Without much resistance I managed to complete the task just before lunch. As I asked my teammate to deploy the changes a familiar demon rose from the depths of our code. The attachments. As we were very close to completing our sprint my teammate took on the bug of being able to upload files larger than 100mb. And he succeeded! All is well.
Trying to load a contract with attachments

Now armed with our giant files the application felt like a Kia Cee'd, in the winter, with summer tires, on ice. After debugging the problem with our mentors we determined, that the fault was in our global usage of the dbset, which lazily loaded the attachments with every contract you accessed. After rewriting our usage the application was loading our contracts with blistering speed once again. Yay!

Everything else taking advantage of our glorious lazy loading however was now broken. With some trial and error we started weeding out the troublesome places. This was no simple task since writing the project has been a team effort so we didn't know where someone might have used lazily loaded attachments. Also each person themselves hardly remembered the places where they used our beloved attachments.

After many hours of not very effective debugging we managed to get a working demo out. When we left the Java team was still there, God knows what they are doing there. The demo is at 9:30 am. Testing is at 9 am.

Day 17

Today we instinctively started talking about tasks before the stand-up even officially even started. Everyone who arrived shared what we wanted to do today and what tasks we would be taking on. As it was first come first serve type of situation we had divided all of the juicier tasks, meaning the ones that required more time and effort. As our last member walked in all they could do was take on some of the smaller tasks and help others. By now it was time for our actual stand-up. So we reflected on what we had done yesterday and filled our PO on what we had planned for today.
This is not the stand-up you're looking for

I ended up with the task of integrating our project with the previously completed part of the system. I've heard some horror stories when people have been dealing with integrating systems together, so I was cautious when approaching the task. Luckily for me it was a tiny change, only requiring changing 2 tables and the code connected with them.

As that would be the juicy part of the solution I naturally decided it would be smart to leave this problem for the evening, when I'm tired and there are no mentors to help you. The other task of submitting data to the other part of the system was straightforward and I had done it by lunch. As I already had some momentum writing the code I tried to keep it going by moving to the harder task.

The right approach would have been to map out what needed to be changed and what changes in the system when I make my changes. This calm and collected approach would have saved me time in the long run. Boys being boys I went in guns blazing. The database change was completely painless as it had been done on the first day by one of my peers here in Bootcamp. Then with some back and forth I changed the views to contain my id and text for the user. This was somewhat challenging, but it did submit to a few wild swings of the hammer.

Now it was time for a seminar about software development in Helmes. The seminar started with our presenter Eliis Väert asking each and every one present about what we would like to hear about. We went over the whole process how development happens in Helmes. Starting with finding clients and how the analysis process takes place. The duration and requirements for the analysis can vary wildly as the client can come to Helmes with just an idea or have their analysis done already or they want to use the waterfall method. To quickly mention the stages of analysis are called
QuickStart → R&D Meeting → Scope definition & solution design → Presenting solutions → Offer presentation & contract. We moved on to the kick-off, where development starts and the number of  team members are ramped up. As a part of kick-off we fleshed out the roles in a team and what the function is for team lead,  analyst and lead developer. We discussed the problem, that the product owner is not always available or great at developing backlog and how the extra load is carried by the 3 more senior roles in a team. After the development cycles comes the release of the MVP. This means that the system needs to be supported by the team. There may be additional developments for this client, but it might just be all the client needs and need for the code to be maintained. This creates a problem of motivation for the team as no new technologies are introduced and the team happiness may suffer. A solution can be to rewrite the system whenever a functionality is requested. We ended the talk with some differences in finding clients in regards to culture, preconceptions, ease of communication and briefly discussed how these differences could be overcome.

After the talk I refined the previously written hammercode with a small chisel. Apparently thinking about your solution and stepping back for a while helps, who knew? The rest of the evening I battled with some errors and quirks caused by my changes. Fortunately by the end of the day I fixed it with some levelheaded help from my teammate.

Tuesday 22 August 2017

Day 16

Our last week of bootcamp. Feels sad. But the development cycle must continue. So the day started with a stand-up. After laying down our daily plans, we set to work on them.

Writing code became more of fixing the bugs and tying up loose ends. Getting into the nitty-gritty, making the UI understandable and appealing to the eye. All of this is highly time consuming and often does not produce the same level of satisfaction as adding a new functionality and figuring the problem out. This is more of a fine tune of the existing code and takes a lot of time and rewards the programmer only sparingly.

Did I break something?


With small tasks and improvements on our sprint board we chugged slowly closer to completing this sprint. By the end of the night we came to the realization, that we needed to get more stories. We scheduled a meeting with our PO, who so conveniently is always here for us. We took on a few new stories and gave assessments to a few more, that we didn't dare to add to the sprint, but if we had the time, we could get started on them. Not pure Scrum, but in the duration of the sprint it will be beneficial. Remember when I said we will play paintball on Tuesday?

Yeah! We played paintball today! We met up at Männiku where we were provided with the gear and the battle commenced. The first two games on the open the Java team dominated and won them in a convincing manner. But then the change happened, we moved to the area with terrain and it was clear, that the superior wits of the .net developers would triumph here!
Yeah..No. I don't know what Java team was compensating for on the battlefield, I guess we will see during the demo on Friday. They took the two next rounds even with strong opposition shown by the .net team. The last two rounds were split by the teams. And in the final round the Java team gained the upper hand once again. A dominant victory for Java team, but it was fun for all participants. Great experience, great people!

Day 15

As the day started with stand-up we had little to report on what we did yesterday as we had had a half day of programming since we had the sprint yesterday. So we focused more on what we were planning to do today.

The day after the sprint is always the most rewarding day as you can just crudely write code and see the features being implemented. These days have become my favorites and I had a nice time filling the criteria in my story. That is until I hit a roadblock. I needed to filter our contracts by date and had to send the date as a GET parameter. This didn't work since the default InvariantCulture was using a different format than our date fields. So I opted to write a slightly modified model binder that took the datetime object and parsed it the way I wanted. As I hadn't done this before it took me a lot of time.

Some days you just get stuck on a problem for hours and solving it takes way too long. Meanwhile my teammates were skillful enough to avoid all of this type of pitfalls and the progress made was significant. We were confident we would have to take on new tasks by Tuesday as we left for the weekend. 

How things are in the Java team ¯\_(ツ)_/¯

Friday 18 August 2017

Day 14

Today started with sprint planning, we still had a nice backlog for our project so for us we just assigned story points to our backlog and added them to the sprint. The beginning was easy as we were adding new features that did not conflict with our completed stories. When we hit the famous attachment story about Power of Attorney documents, then our team decided to revisit the attachment module and make sure we would be able to support attachments over 100MB. This was taken on as a big story and it pretty much concluded our last sprint for us. 
Our last sprint :(

At 11 o'clock we had code review, where our code was deemed good, but we should make use of Linq more in our queries and iterations. This is somewhat easier than our Java team, where their code had to be more readable than this blog.
Java mentors when reviewing code
With our new tasks in hand we assigned them and everyone was busy working on their problems until the internet connection was gone from the whole house. As this happened half past 4 already most people decided to call it a day and head home. We on the other hand had our paintball activity event planned and it would be easier to leave as a group from our offices. So we waited out the internet issue, that only took about 25 minutes.

About 30 minutes before we were to leave for the event Oliver came into our room asking "Have you seen the weather?". We were caught by surprise as we had no windows in our room, "It's pouring rain outside!" Oliver explained. We still decided to give our group activity a shot, maybe it wouldn't rain there.

So yeah, it rained there. We rescheduled the team event for Tuesday and currently we are praying for good weather.

Wednesday 16 August 2017

Day 13

Today is the demo day again. Wow time really flies when you got some problems to solve. Time had not flown as fast for my team as it had for our other team though. Beginning their last day they had completed half of their stories.

Due to us having only one story to do for our day and the testing being done for other components (Yay for taking on more stories at the end of the sprint), we tried out the fabled quad-programming, where one person codes, other person observes and two others are just distractions.

This was pretty much our day up until 1 hour before the demo when we experienced our first server downtime.
Our server got knocked out! We alarmed our bootcamp main organizer Oliver, who sped us to the Ops room, where they were aware of the problem and laughed at our timeframe of needing to do a demo in an hour. "Plenty of time." they said and asked "Do you want to install updates while it's down?". Joking aside the server was up soon enough.

Did our deployment still work? It did not. So we needed to redeploy. We went over the changes we had made since the last deployment and speed-tested it. Now or nothing we used the luck we had and deployed our newest publication.

The time for the demo was here and the Java team went first. Having complained for the whole day, that they had nothing to present to the client to due multiple blocking stories, they sure did have a lot completed. They had chewed through most of their harder tasks and those not implemented were just tiny features on the good foundation that they had. The demo was a screaming success.

Same goes for the .net team, but with less drama and simpler demo.

The Sprint retro was highly positive and everyone found more good points to put on the board. This concluded the sprint for us and we were free to go home.

Yay for an early day

Tuesday 15 August 2017

Day 12

The morning stand-up revealed, that the sprint is looking good and all we have left is a bunch of testing and deploying.

We wanted to  get all of our tasks finished and deploy our changes to the test server before our PO demo at 1 o'clock. This challenge we managed, but we still couldn't fully demo it on the test server as it had some issues.

The demo went well and we got positive feedback from our PO. She highlighted some problematic decisions we had made in the design and gave us some feedback on what to work on next. Our PO also offered to test the authorization in the test environment, when it was operational. So getting our deployment running is what we focused on after the meeting with our PO. We only had 30 minutes to tackle this problem, because we had a meeting with the CEO of Helmes scheduled.

In the meeting we got to hear the day-to-day operations Helmes CEO has and how he helps the company run smoothly. Biggest revelation being that a manager has done his job well, if he is not needed by his subordinates. He spoke about attracting clients and described how the process can be a long one, especially for big multinational companies. Creating a link between your company and the other company is key in making future deals happen. Many big contracts with over 80 people working on them today have started with projects assigned to a team of 2. 

After the meeting we were back in the world of fixing our deployment. We had an issue with seeing all the contracts when logged in as an administrator. We couldn't figure out why the administrator didn't have all the rights he/she would need. As we couldn't just access the code running on the server we really needed to access the logs. Guess who didn't log their project? 


With a bit of messing around we got some logs to show up in the database, but still couldn't figure out why we were getting this error. But then I remembered, that we use AppConfig to store some variables. And the only file we didn't overwrite or even check when deploying? Yes, we really are that stupid.

Our mentors actually warned us about this and recommended to use a nice tool called TotalCommander, that allows you to compare contents of a folder and displays files that differ and enables you to view the differences in them. Being brash bootcampers we didn't heed these suggestions. May you be smarter than us.

We finished the evening by getting 2 more stories for our sprint and started on them.

Day 11

Over halfway through with our bootcamp. Time has really goes by fast when you're working on something new and complex. Mondays stand-up is always the hardest, because the 2 day break usually throws a wrench into the mix. Stand-up worked well as a refreshment on what we were working on and gave us an overview of the fact, that while we are closing in on finishing our stories, the testing has not yet been even started.

Even though this was the case we decided to finish the story as they were separate enough to not need any testing in between stories. I decided to unit test the logic of one of my more critical functions and as I didn't know much about testing this took a bit longer than expected. With some further complications presenting themselves during writing the tests it took me until lunch.


After lunch we had a seminar about UX&UI. The lecture part of the seminar went through the lifecycle of UX projects. It gave us recommendations how to create a better UX for the user without needing user input at every step.

The main emphasis was on seeing the problem and process through the eyes of the user not the eyes of the developer.
Some were excited about the lecture

Others had other ideas about it.

After the lecture we got to show our UI to our lecturer and get actual feedback. By sheer luck .net team went first and out of the feedback we got some good points, that we can include in our future stories. Unluckily for Java team the time ran out, so they had to rush their presentation. For this reason or maybe they just did a really good job, but the feedback was all positive and no changes were needed to be made.

And the rest of the day we wrestled with some inconsistencies with test data and real data. With some workarounds we got a testable and a working solution.

Monday 14 August 2017

The 10th day.

Today is the 5th day of straight-up programming for us. Our stand-up was nice today as everyone had completed something yesterday. I was proud of my team. Luckily for me our PO caught a mistake in the problem I was trying to solve and guided me towards a better solution to the problem. Whilst this still wasn't the final solution to the problem it was a step in the right direction. I see this as a plus for agile development and stand-up.


So with that nudge in the right direction I was making fast progress on my issues. But the 5th day of programming was weighing on me and by lunchtime my head felt just as agile as a potatoe.


Having a nice lunch helped a bit and I could tackle some more problems. My team was feeling the struggle of becoming a vegetable as well. At some point one of our merges broke our attachment feature. By the time the clock hit 3 there were no more programmers in the room, but potato. Potato everywhere. The productivity dropped off a cliff. I'd say there wasn't a usable line of code written after 3. We actually went to our PO 3 times trying to figure our how to deal with linking our contracts to people working on them.


Luckily enough one of our team members had had a birthday a few days earlier so we had a small break wishing him the best and the Helmes staff had some handmade candy for him. Shortly after this we had a discussion what our next weeks team activity will be and we decided on paintball. Hyped for that!

And the day ended with us filling out the first part of the feedback about our experience here. Totally remembered what we did on the first day, honest.

Do you remember?

Friday 11 August 2017

Day 9.

Another day, another stand-up? Not today, brother! Today is our second sprint planning. We are well armed with a plan to improve our codebase and do much more than the last sprint. With this positive mindset we started the morning rewriting our code so we could use repositories.

And then we got some more great news, our PO had written up a lot of new stories, that we could include in the sprint and didn't even have to give input on. This saved a lot of time and we could plan this weeks sprint in just over 2 hours. And we also kept our Sprint retro suggestions on hand so we would have more unrelated stories and gave our estimates with a bit of room to do refactoring.

With our stories selected we started writing some sub-stories to explain the story better and as we had unrelated tasks we could do this at the same time! Felt productive and great. Then we introduced the sub-stories to each-other and added some points we could have missed. With that done we could get coding.

As the first order of business half of our team finished up refactoring the existing code while others worked on their stories. This created a bit of a disconnect between trying to complete your bit of the problem as bit part of the system was going through some changes. So in order to not be like our Java team and avoid massive merge conflicts we discussed it so we wouldn't change the main part being refactored and it really worked out. Talk to your peers, people!

The day came to a rather early end, because today we had sauna and board games scheduled. It was funny seeing our teams of 5 looking blankly at the floor for the first 10 minutes, because the mind was intently fixed on the task that was abruptly cancelled by the announcement of arriving pizzas. Early communication was a bit rough, but after we got to playing some saboteur the chat started flowing more freely. Some classic jokes were made as the evening rolled into the night.

Thursday 10 August 2017

Day 8. First demo

At the start beginning of our morning stand-up it seemed, that most of our stories were completed, but during the discussion it turned out we still had some features to add.


We started work on the features without too much panic, because the sprint demo was at 3 pm. With the tasks related to the sprint demo being in progress we tried adding some functionality from outside of the scope of this sprint. Our mistake in this was, that we also tried changing the part, that was in the sprint. This caused a big part of our system to have buggy implementation 2 hours before our first official demo.


This meant that it was time for our first hotfix, to restore the previous functionality in time for the demo. With this done we had an introduction to Jira for our next sprint.

The demonstration was up next and after a nervous start everyone got the gist of the story and our Product Owner had to decide if she accepts the story or not. I'm happy to say all of the stories presented were accepted.

With a successful sprint behind us it was time for our retro. As we stickied our ups and downs during the sprint we had some patterns emerging. On the positive side our teamwork is good. On the negative side.. Oh boy.. If Estonians are known to be critical of things, then in this sprint even our Georgian teammate ran out of red stickers. The conclusion for the bad part being : Task planning, Different views on programming, Code quality, Testing.

The last thing we did was discuss our codebase and decided to add The Repository Pattern to our existing codebase and refactor the existing codebase.

Tuesday 8 August 2017

Day 7. Lucky number 7 they say..



Today our day started with the stand-up becoming easier and more informative at the same time. Our team is getting to know each-other and it feels great.


The bane of our existence has been implementing a file attachment feature. There is an existing one, but that just makes the decisions harder. Should we use the existing one? Should we use a hybrid? To even attempt to answer this, you have to understand the existing code. This is something that makes my head boil, as writing code is hard enough, but understanding why someone else has written their code in their own special way is just that extra nudge, that makes you want to take a breather for 15 minutes.

What can be worse is to struggle with a problem for the longest time and then find out you just mistyped the name by a character or forgot to pluralize a list and after an hour of searching you see it and a wave of relief washes over your followed by a tsunami of shame follows for making these dumb mistakes. Luckily the IDE catches many of them, but the mighty IDE  cannot always save you.

To cool off, we had a nice little team game planned to grow as a team and see how we interact with each-other, when there is a lot of room for interpretation. The task was to decide what should happen with 4 people marooned on an island if they had built a ship, that would be only able to sustain 3 people. The limited information given was that those 4 people were : A shipwright, a doctor, a genius and an extremely wealthy individual.

Our discussion went on for a full hour and in the end, we still didn't agree, with 4/5 people in our team deciding on casting out one person and our last team-member sticking with his choice. But that didn't matter, as I felt that we as a team became more open and everyone got to voice their concerns about the predicament.

I enjoyed the viewpoints my teammates and appreciated the reasoning behind them.
Today was a great day



Day 6.

A new week and we're standing up in the morning again. Ah the stand-up meeting, remembering what you did on friday can be a struggle sometimes, especially with a busy weekend.


With the static views of the tasks being done we are now trying to create some dynamic fields to make it a little 'snazzy' for our users. This is proving to be a much bigger challenge and more time consuming  than initially predicted. But then again, it's more unique, which makes for a great learning opportunity.
The tasks are slowly, but surely inching their way to completion, with some more problematic ones rearing their ugly heads at us and giving us a hard time.

Day 5

We had our first sprint stand-up today! This was new for everyone on the .Net team, but as the concept was simple and communication good, we had no issues with it.

With the first sprint planning being quite thin on user stories, we struggled with choosing tasks that didn't depend on the previous tasks or were ready to be taken on. With limited tasks and unlimited brainpower, we settled on coding in pairs with one person coding and the other observing and vice versa.

The day itself was quite productive, but hasty errors proved to be tough to crack, as the first commit made dealt with a similar issue as the last commit.
One does not simply git push

At the end of the day we voiced our concerns about the bootcamp, the milieu, the people or anything we could think of. All of the feedback was positive and everyone was content.

I for one was exhausted when the week ended, with my mind buzzing with new information.

Day 4. Software architecture and our first lines of code

First thing in the morning our mentor Markus gave us a quick overview of software architecture and demonstrated them with some practical code. He made some good points about code reusability being dangerous when the need comes to alter the codebase. And warned against leaving vulnerabilities in your accessible layer.



Our first sprint planning was a joyful endeavour as we were getting so close to starting to write some code and starting to fulfill the plans made for the last 4 days. With some back-and-forth with the client we managed to create 12 user stories. Assigning story points was a fun and slightly odd experience as during the first sprint planning meeting the story points value is still wildly inaccurate. In the end we decided to take 10 user stories into our first sprint.


After some confusion about splitting up the user stories we managed to get our first stories and tasks on the scrum board. This meant we could take a task and start developement! Right? Well almost, we still had to create the underlying data model. So we split into teams and half of us started work on the view and half of us on the model. It was strange working with multiple people on the same problem as there was more explaining and questions, time will tell what will come of this.

In the evening we had a pub event with our bootcamp team. So this was us arriving there.

We filled out 3 tables in a cozy bar called Kivi Paber Käärid. The mood was relaxed and it was nice to chat to the employees of Helmes without the subject being about the bootcamp. We taught our foreign teammates some Estonian classics such as counting to 12, teaching them how to pick up girls. All in all a great evening!

Day 3!

Agile development and Scrum


The day started with creating vision for the UI based on the information gathered in the client meeting yesterday. Armed with our notes we started hashing our the fields and views to our best ability.

With a baseline design done we were joined by our helpful clients and analysis team, who helped us phrase high level business requirements. In order to do this we had to define a series of points, that would end up helping us form an elevator statement and business goals and their metrics.

The task was not easy
First off we  determined who would benefit the most from our application and they would be our client. Secondly we identified the need, for which they needed to use our application. Then we had to have a great product name for our creation and classed it into a product category. A big aspect was the list the key benefits, that our solution would provide. And to finish off we described what would be unlike the current process e.g. make the process less time consuming and create less errors.

Discussion is key

Don't forget to document your decisions 
Make sure the whole team is on the same page


Afternoon began with a seminar about agile development and Scrum. It was a free-form lecture conducted by Raul Annus, the head of development in Helmes. We started of the lecture with the question why agile development is needed and what makes software development so difficult. In the end we managed to word in our own words a few points :
  • Environment changes fast
  • Very many dependencies
  • Software is only a representation, not the real thing itself
  • Software disrupts the business process
In conclusion we ended at the realisation, that there is never a perfect analysis of the problem and that making something faultless is limited by us being human and making mistakes. In agile you have to make a small usable product and actually test it within the business process as a whole. But in order to build something useful you still need to align the strategic business goals and the business needs, only the features have the luxury of not being right 100% of the time.


After a small break we had a meeting with our stakeholders and intruduced our UI to them. Showing a mock-up of the UI got the team leads creative juices flowing and we got a good idea of what the UI would look like in a perfect world. 

Friday 4 August 2017

Day 2!



The dread of meeting with the client


The preparation


Day 2 started with an analysis seminar, where a Helmes analyst Kaisa gave us some tips on what to do when meeting with the client. Some notable advice was to keep it simple, produce a MVP and don't promise things you can't deliver.


After the seminar we had our analysis mentor helped us to create a questionnaire to maximize the time we had with the client. The questions used the following guidelines:
  • WHO (who is the client?)
  • WHY (why are we doing this?)
  • WHEN (what are the timelimits?)
  • HOW (platform?, existing code?, analysis process setup, communication?)
  • WHAT (the actual business requirements and functionality of the system, what is the actual need of the client)
  • PROBLEMS (what would be their priority: minimum viable problem)

Constructing the questions was no easy task as we had not worked with clients before so coming up with the business process questions was an unfamiliar activity.


Photoshoot

Before meeting the client we gave a photographer the wonderful opportunity to make some software developers smile. 

As seen on the photo below everyone enjoyed themselves and the photographer didn't have a hard time at all!


The meeting

The meeting with the client started with everyone introducing  themselves and their role in the project. With the introductions over we hunkered down with our questions and started trying to get the information we needed from the client. Our initial plan was to ask about the high level idea of how the current business process worked and what the problem with it was. Having asked the question we were barraged with information about what the problem is and how the new system should fix it. This may have been due to me asking the question we had previously written down more palatable. There's a lesson in this, make your questions clear and concise and perhaps take your clients background into account as the client was knowledgeable about the system and it's requirements. Thanks to a great scribe we managed to get a lot of information about the specification. 

The second surprise came when about 1/3 of the way into the meeting I realized I had completely misunderstood the problem. You see, I thought we were to make a system that creates and saves contracts. This was due to my poor understanding of the project brief given to us earlier. Actually we were creating a system that added some metadata to the contracts to make them accessible. With a flustered face I kept calm and carried on.

After the meeting our mentor said the data we had gathered was good and the meeting went very well. We systematized our notes and headed home for the day.

1. day! Introductions and workstation set-up.

Introductions

The bootcampers with Helmes staff
On the first day at the Helmes Bootcamp we met the two teams in the bootcamp and the bootcamp team, who will help us on this exciting journey. We had a introductory meeting and saw and met all the people  who will be directly interacting with us. The mood was light and everyone was friendly. We also got an overview of the core values of Helmes with the uplifting slogan of "We want to be the best software services firm in the world.". True enough, the inquisitive mind of the bootcampers wanted to know, how being the best is measured and the answer is by employee happiness, client happiness and efficiency.

The aim of the bootcamp will be to offer an intensive software development training, see what Scrum is in practice and to complete a full software development process. The evaluation criteria for the bootcamp is surprising compared to the aim with 30% of the evaluation coming from the result of team work. Helmes really seems to value interoffice relations. Achieving business goals will determine final evaluation by 25%, following Scrum principles 20% and code quality and successful sprints attribute 15% and 10% respectively. So coding proficiency is not the most important aspect by a long shot.

The teams and projects

This year there were 2 teams taking part in bootcamp: a Java team and a .Net team.
Projects for this year were Licences allocation and Applications Accesses and Contract Register. The Licences allocation and Applications Accesses focused on managing licences that are distributed within Helmes and aimed to help managers free up unused licences. This project was assigned to the Java team. Contract Register aimed to add a new module to an existing application, that would help Team Leaders manage contracts. A clever person would assume this was the assignment for the .Net team and they would be right!

The setup


After the introduction of the projects it was time to set up the workstations and attempt to get our first commits to the development repository. After installing all the prerequisite software the .Net team ran into a problem with connecting to the development database and we were unable to verify that the base application worked. Java team did not have this problem and they were off to the races, learning about git commands that they had not used before. While the Helmes staff debugged the problem with the connection we got some tips from our mentors and I personally learned, that more often than not, if you don't build logging into your application as you build it, you will never add it afterwards.

That was it for day 1!