1. Know Thy User For He Is Not Thee

David Platt (President of Rolling Thunder Computing, Inc., instructor in Computer Science for the Harvard University Extension School) talked about the problems of software products in general in his lecture Why Software STILL Sucks. He explained the importance of knowing the users and what they want from a software. This is something we all think we know but it bears repeating: always make sure your software tends to users’ needs instead of just providing “cool” looks and complex functionalities. The most common demand is “I just want it to work”, therefore, make sure you are doing exactly that – “Making it work”. David also gave some tips on how to improve our software:

• Use the help of interaction designers: it’s important for your software to have a good design but it’s more important that the interactions are easy, smooth and intuitive. Coding isn’t the problem, choosing what to code is the real problem.
• Test, test, test: you should always invest time in testing your product. You can even ask friends or random people to test your software before releasing it and listen to their feedback.
• Quantify your code: try to come up with some metrics so that you can compare how one version of your application is better/worse than another one. A funny example is “WTFs per usage”: count the number of times you say What the hell is this? while using an application to do a task. Then compare it to another application that allows you to do the same thing but differently.
• Baby steps: make sure you fix small things that ease up the process for your users.

David has a whole book in which he talks in depth about all these and more. You can find it in Amazon

2. There’s no such thing as an untestable behavior, only an untestable code

Pawel Dudek (iOS developer and team lead @ Toptal) talked about Behavior Driven Development (BDD) and how it helped you maintain a good software architecture. He also explained how BDD aims to improve certain aspects of TDD (Test Driven Development). Pawel shared a couple of his ideas and good practices of testing.

1. The unit test is a failsafe to make sure your application behavior is preserved.
2. Tests influence the architecture of your application, therefore, a testable code equals a Good architecture.
3. When writing tests don’t think tests, think behaviors.
4. You should only be testing the public interfaces of your objects, not their internal implementation.
5. Use ubiquitous language to make examples understandable.

You can find Pawel’s slides from his lecture here

3. Opti-pessimism: Design for the best case, build for the worst

Cheryl Platz (Principal designer @ Microsoft) shared her ideas about “opti-pessimistic” product design. According to her, there’re three techniques you can apply to your product design process in order to consider the best and the worst of what your product has to offer:

1. Ask yourself the hard questions. Artefact’s Tarot Cards of Tech can help you do that:
   1. Does my product make the world a better or a worse place?
   2. If we’re too successful, how could our customers be harmed?
   3. How can our customers abuse our product?
   4. What is the words case impact our product could have?
2. Explore the human context – don’t build products that your customers don’t need.
3. Design for the best case, but build for the worst.

We highly recommend you to check Cheryl’s slides here

4. Atomic design

Amit Zur (Frontend consultant, developer & designer @ Happy Code) showed us how he implemented the Borland Turbo-C editor using the concept of Atomic design with the help of React, MobX and Node.js. The atomic design consist of three types of elements:

1. Atoms (e.g. Color, Font, Spacing, Text)
2. Molecules (e.g. Button, Paragraph, Dropdown)
3. Organism (e.g. Search bar, Notifications)

Pretty cool when you look at things from this perspective! You can find Amit’s slides here

5. AI can be fun and easy

Julien Simon (AI & Machine Learning Evangelist @ AWS) unleashed the power of the AI in his lecutre AI for developers. He used his robot Johnny Pi designed with a Raspberry Pi to demonstrate different capabilities of the Amazon Web Services Machine Learning. The little fellow could understand simple commands like “turn left/right” and do complex tasks like image recognition and hand-written text translations. That was adorable and at the same time, brain-racking what we can achieve with the help of AI and how it can change the course of software development. Just imagine…

6. (bonus) Beware of the Greek mosquitoes

No joke here! The first night was rough because of the raging mosquitoes. They were quite active during the evening when we decided to explore the city. If you plan to visit the conference next year (like we do), make sure you’ve loaded some lifesaving sprays and ask your hotel to give you an electric mosquito repellent, too.

Let’s admit it, DEVit was a great conference! We’ve talked to extraordinary and talented people. The lectures were both entertaining and useful so a big THANK YOU to the DEVit staff and speakers. And of course, to all attendees who came and stopped by our booth. What really made us happy was that we’d met people who knew the value of Atlassian expertise and were interested in our services.

We can’t wait to come back next year sooo… see you all then!