In this short summary I will describe the main topics of the conference and I will point to some good talks I’ve seen.

Metaverse

In simple words, the metaverse is a virtual place on the Internet, where people can join and do some social activities (like playing games, doing meetings and so on). There is an assumption that such a world will be visited using the Virtual/Augmented Reality headset – but this is not a must.

It looks like this topic is trending right now and many big companies (like Meta (Facebook), Microsoft, Google) want to develop software in this area.

This subject was represented by two talks:

• “The Future of Computing with Spatial Computing and Quantum Computing” by René Schulte – a nice overview of the metaverse and what can be achieved with it.
• “Foundations of the MetaVerse: Azure Spatial Anchors and Understanding 3D Space” by Andreas Erben – quite a heavy introduction to the ways Metaverse could be implemented (and used) using the Microsoft Azure cloud.

Software quality and architecture

As always a large part of the conference was devoted to talks about how to write better code. Here I could recommend those presentations:

• “Why GraphQL is Perfect for Microservices” by Roy Derks – a nice introduction to the GraphQL query language and its usage to create a consistent API layer on top of all microservices APIs 
• “Domain-Driven Refactoring“ by Jimmy Bogard – a live coding session which presents a way to refactor a typical web application code into the one that applies Domain Driven Design. If you start with DDD this is a very nice presentation to watch.
• “Consistency and Agreements in Microservices“ by Jimmy Bogard – an overview with some code examples of how transactions could be implemented in a distributed system.

Soft skills

Most conferences these days not only have technical talks, but also there are a bunch of non-technical presentations about various themes (starting with business topics and ending with topics that inspire to action)

• “Can Virtual Reality Change the Real World?“ by Piotr Łój – this talk influenced me the most – it shows how VR technology can help kids in their fight with their serious diseases or disabilities. Piotr does amazing work in his foundation, so I encourage you to support his work!
• “The Effective Developer – Work Smarter, Not Harder” by Sven Peters – an interesting study on how software developers should not only focus on writing code, but also on many more aspects like:
  • the business they are working with
  • the interactions with other people in a team
  • expansion of their knowledge beyond the topics they know from work
• “Building a Software Company From The Ground Up – Facts, Myths, and Everything In Between“ by Spencer Schneidenbach – in spite of its title, this talk could be interesting even for people who don’t want to create their own company. It not only shows some more technical stuff about running a software house, but it also shows what values make that the software engineer is good in what he does.
• “Use Principles of Psychology to Build Better Software” by Rachel Appel – this talk is a good reminder that while writing a software we should always think about people who will interact with it and how they view our software.

Final words

Overall, it was a good conference. I enjoyed all the talks – regardless they were more or less focused on the technical stuff. It’s always nice to meet with other people and exchange knowledge and experience with them.

The post DevConf 2022 appeared first on Yumasoft.

My conferences story

Back in 2015-2019, I used to attend conferences in person only. My first events included GET.NET in Łódź and WROC# in Wrocław. Then I attended .NET Developer Days in Warsaw two times in a row. This one was the first big-size programming conference I took part in.

Back then, I was a newbie junior programmer. I was also a bit shy to talk to people. Probably I had a huge impostor syndrome, as I thought everyone there was better in programming than me. I attended many sessions, even though I didn’t understand many technical aspects and never used them in real life.

I also always used to go to conferences and even meetups with someone I know (a colleague most of the time). If no one was going, I didn’t go alone. This didn’t help in becoming less shy and starting to talk to people I didn’t know ?‍

And then it happened. In 2018, I decided to go to InfoShare conference. Alone ? I still wasn’t very open to talk to anyone encountered, but I was a little braver. I talked to a few awesome speakers, including Michał Szafrański and Marek Jankowski. Those guys really were inspiring to me before, so it was an awesome feeling to talk to them face-to-face ?

InfoShare conference changed my life. It was another booster to make significant changes in my life and become a digital nomad. Several months later, I started working fully remotely for Yumasoft and traveling the world ?

There were some awesome guys like Michał Śliwiński speaking about a fully remote companies at that time already:

I also felt great after attending the NDC Porto 2022. After not seeing fellow programmers in person for more than 4 years, it was awesome to finally be more open and talk to many people at the conference. I was also alone this time.

Talks or people?

What can we take from my conferences’ story? As you read it, you can easily notice that the only things I remember are people. Either talking to one or two speakers or chatting with many people attending the event. That’s what I remember from the event. Technologies and tools come and go, but people stay. You stay connected with them on Twitter/Instagram. Think how nice it would be meeting them again at another conference by coincidence!

On the other hand, I remember almost nothing from Boiling Frogs 2021, which I attended online. That’s how it works for me.

I have to go back to the blog post or my notes to get something from it. This is also useful – that’s why I make notes. However, for me, this is not the real goal of attending a conference. All sessions are anyway recorded and in most cases available for free online after the conference. The community, interactions, Q&A sections and conference parties cannot be transferred to the online world and provide the same value. For me, it simply doesn’t work.

Conclusions

For me, conferences are the people. Not the talks.

However, I had to learn it throughout the years of attending several conferences, both offline and online. That’s why I wanted to share my story with you at the beginning of this article. To give you my perspective.

If you are about to take one thing from this article – please open yourself and talk more to people at the conferences. Try going to a conference alone, or if you go with someone – don’t stick with your fellows all the time. I know this is going out of your comfort zone. I still feel uncomfortable doing that, but I’m trying to improve little by little. If each of us makes a little effort, it will overall become much easier for everyone. Maybe next time I’m walking around the conference room getting stressed on selecting a random person to talk to, you’ll reach me and initiate the conversation? ?

The post Why Do You Attend IT Conferences – For Talks or For People? appeared first on Yumasoft.

.NET

This is going to be the longest section of this article ? I think it’s a bit specific to NDC Conference (“.NET” is the first one on the list of proposed topic for an NDC talk), but there was a lot about .NET. There were quite a few speakers either working for or associated with Microsoft.

I think the most discussed .NET topic was Blazor. There were many sessions discussing various aspect of the Blazor framework, its new features and development. MAUI was also mentioned several times.

Except that, .NET developers and speakers seems interested in issues related to the new versions of .NET (.NET 6/7) and generally this whole new ecosystem that’s being formed. Topics included gRPC/gRPC web, as well as Roslyn compiler possibilities.

Another important area of .NET was the multi-platform thing. It seems to be very important to the teams at Microsoft and contributors to related projects to make everything working on as many platforms as possible. Including desktops (Windows, Linux and Mac), web and mobile (Android and iOS). There were at least few multi-platform solutions discussed several times: Uno, Avalonia, Blazor and MAUI. All seem to be solving similar problems, but each has different entry costs and technologies used.

Software architecture

From software architecture topics, the most popular seemed to be everything around DDD. Not only the fully religious implementations of DDD were discussed, but also some of its simplified forms or just few concepts extracted from it.

It seems it’s all about understanding our end users better. I like it ?

Cloud

Possibilities of various cloud providers were discussed at almost every talk I attended. What I liked about that, is that it was not only Microsoft Azure discussed everywhere as it used to be few years ago ? Cloud is now seen more as a concept rather than concrete cloud providers’ possibilities.

While we still need to support on-premise deployments, cloud seems an inevitable way to go for many applications.

Web

WebAssembly and accessibility. There were the two topics discussed very often in terms of web technologies. Some sessions touched on React, but rather briefly. I even didn’t hear about JavaScript very often, which is actually weird ? TypeScript was also a topic, as well as some frontend testing techniques/frameworks.

UX

I attended two sessions about UX. This is quite interesting for me, as I think we can do much better in terms of usability of our software for the end users.

In general, I love the concept of designing and implementing the application from the user’s point of view. Maybe it sounds obvious, but it’s not always like that. Especially in corporations, when there are several layers between programmers and end users. Each layer adds its own filtering. This process makes the final solution sometimes far away from end users’ expectations.

Soft skills/team leadership

Not only technical stuff at programming conferences in 2022? Sure ?

I also enjoy team leadership and light-management topics. Although not many programmers I talked to especially love those talks. Except the ones who have actually managed people. There were, however, quite a few sessions on that, and I liked them. I think leadership is translatable to everyday life, not only work.

Conclusion

My general feeling after NDC Porto 2022 is that we all want to be focused on people. We want to take care of our end users, but also of ourselves ? The main message was to make everyone feel welcome in IT. Especially after the pandemic, which increased anxiety and reduced the importance of social aspects in software development. I think programming conferences in 2022 should cover these topics.

Technical stuff is important – without that we can’t make anything. However, we are all people, and we need to take care of ourselves first, so all of those awesome tools can be used effectively and to everyone’s satisfaction ?

The post What Do People Talk About At Programming Conferences In 2022? appeared first on Yumasoft.

My last conference was the online Boiling Frogs event, which I attended remotely from Indonesia. As you could read here, I was generally happy with the sessions, but something was missing. This missing piece was community. A real one. Physical. The community you can touch. And talk to ? I didn’t even realize how much I missed that. Until I attended #NDCPorto 2022.

Firstly, Porto is an awesome city for an in-person conference. It offers a mild climate, especially by the end of April. The temperatures were around 24 Celsius degrees during the day. It also does offer wine, of course ? It all means that you can enjoy a technical event during the day and still have some fun and socializing in the evening.

I lived in Porto for 2 weeks in September 2020 and really loved the city. It’s charming, not overwhelming and very appealing. It’s also a students’ city, so you can feel that young vibe – lot of street bars, people drinking beers or wine starting late afternoon until very late night.

All right, let’s get to the point. NDC. This great, first in-person conference I attended since 2018. I will not talk about the sessions here. I will talk about the people.

I tried to list the most-talked-through topics from this conference. The only real conclusion I can make, is that everyone I talked to, at some point said “It’s so great to be back in person”, or something very similar. The pandemic has taken a lot from us. Now it’s time to get it back.

I didn’t realize it, but the remote work time made me a little anxious with talking to people ? I’m not talking about pandemic, because I was fortunate enough to spend most of it in Indonesia (yes, Yumasoft is fine with you working from another continent!). Before I started working remotely, I used to be a Team Leader. It made me talk to so many people at the office every day. I always thought I’m rather extrovert than introvert. However, I was very curious to see how it is to interact with people again.

Before going to NDC Porto, I promised myself I will be starting chats with random people. Especially that I was going alone and didn’t know anyone there (except a few of the speakers). At first, I felt a bit stressed to just chit-chat to random people at the conference ? But then, after I started talking with the first 1 or 2 people, it felt great. It was so awesome to exchange opinions. Not only on coding, but also on pandemic, remote work and everything it changed in our lives.

There was also a great opening keynote by Scott Hanselman. He covered few very important topics related to pandemic times. Scott mentioned burnout, anxiety and onboarding issues while working remotely. Of course, he also proposed few solutions everyone can implement quite easily. Just watch it yourself.

During the conference, I also attended two socializing events. The first one was a diner with wine tasting after the 1^st conference day. It was an additional event everyone could sign up to, but was not officially part of the agenda. I’m very happy I went there, as it was another chance to meet some great people, including few of the conference speakers. On the 2^nd day of the conference, there was an official NDC Party. Very well organized, again allowing for socializing and exchanging views on various topics. Not only software ?

Conclusion

My conclusion is that the online events will never be a substitute for in-person ones. They are just different. I don’t feel the community and interactions at online events. There might be a chat, but it’s not the same.

I encourage everyone to attend in-person events from time to time. It doesn’t need to be a big in-person conference in a foreign country like NDC is (although I definitely recommend that!). Look for local meetups in your city or smaller conferences in your own country. Go there and overcome your fears and anxiety about talking to people. Just do it – talk to random people you don’t know. You will feel awesome, believe me ?

Attending a conference not only makes me wanting to try 10 new frameworks which I will forget about in a week. It makes me feel that we have an awesome programming community. That we are not alone in what we do. That others face the same pains we all have, like impostor syndrome or feeling stagnated at work. I got to know that other developers are not magicians and geeky coders who don’t use StackOverflow. Not every programmer’s job is his/her hobby. They are just normal people like me, with their own pains and fears. And that is awesome! ?

The post How Does Attending An In-person Conference Feel After The Pandemic? appeared first on Yumasoft.

On 20th March 2021 I had a chance to attend the Boiling Frogs 2021 conference. The event was held 100% online this year. I was not sure whether this was a good idea to take part in an online conference, but finally decided to try. In this article I will try to point out how the event was organized, what worked and what could have been better in my opinion.

Boiling Frogs 2021 – the platform

Organizers of Boiling Frogs 2021 decided to use Hopin for hosting the event. I must stay that it was quite well-organized and worked very well. That’s how it looked like:

The Expo section allowed to switch between tracks (there were 3 different talks taking place at the same time). This worked smooth. As you can see, on the right panel an online chat was available. It was possible to ask questions, which were collected by moderators. The questions were then either answered by the speakers at the end of their session or asked in a special Q&A available in Sessions section after each presentation.

The Q&A was a very good idea. Each speaker was available for several more minutes in the Sessions section and anyone could ask questions. What is more, anyone could connect with video and mic to ask the question more personally ? It made it feel like the community is really there.

The videos were transmitted through Vimeo, which made the quality great.

That’s it about the platform itself. I think Hopin was a good choice for an online conference. It made everything smooth and easy.

The sessions

This article is not a “sessions-describer” article, so I will not summarize every 8 sessions I attended. I’ll just point a few ones that were the best and what I learnt from them.

Tomasz Kaczmarzyk – Żywot programisty poczciwego (EN: Kind programmer’s life)

This was a very interesting talk, also touching some issues that we face every day at Yumasoft. The speaker started from wondering what the programmer really does. Are we really just coffee-to-code-transformers? Or we should rather be problem-solvers, who tries to think from the user’s point of view? The whole talk was oriented towards the issues in software design and understanding customer’s problems. Unclear requirements, changing the requirements too often or throwing the already-done work away were one of the issues we all face on daily basis.

The particularly interesting statement was that some of these issues are of course the issues with the design, but a lot of them are driven by programmers’ ego. When the developer gets the requirements that are not clear, (s)he often thinks “I will not be able to implement that?!” and goes on with the work. Instead of rejecting such a design and asking for clarifications.

The other issue is communication – both between programmers and non-programmers and the developers themselves. Overcommunication seems to be one of the solutions here. However, we should also try to wear customer’s shoes and try to understand the problem we are going to solve. As soon as we see some unclarity, we should not bother to say “no”.

I think this is particularly important to try to understand the domain and the root of the problem we are going to solve with the code we deliver. The non-programmers (clients, designers, analysts) are not infallible. That is why we should not think that our “no” will offend someone. On the contrary – it will help. In the end, we are all a team, and our goal should be to deliver the solution of our end users’ problems, not to show who is more powerful and whose design decisions are the only truth ?

Łukasz Szydło – DDD – to jednak nie takie proste (EN: TDD – that is actually not that easy)

This was a great presentation about Domain-Driven Design (DDD). As always, Łukasz delivered funny and, at the same time, very useful content. The presentation was of the kind I like – not to “sell” some new concept and evangelize everyone to start using it straightaway after watching the session, but rather to analyze when NOT to use it. The speaker pointed out some of the concepts used in DDD and – based on the projects he took part in – advised when to use them and when to avoid them. For example, according to Łukasz, aggregates are not always needed, e.g. in case of modeling a calculations-only system, like a flights search/comparing engine, which only fetches the results from external services and only does a complex calculations on these results in the end.

The discussion panel (Andrzej Krzywda, Łukasz Szydło, Mariusz Gil)

This is the last thing I would like to describe from the conference’s content, because it made me feel the community of Boiling Frogs 2021 even more. The discussion panel hosted 3 speakers who were answering questions asked on the chat. The discussion was mostly around DDD again, but I do not want to talk about the topics here.

I want to emphasize that the discussion panel is what makes on online conference more like a stationary one. This is what we used to attend normal conferences for – to meet people, ask them some questions and interact. Q&A sessions and the discussion panel reminded me a bit about sitting in the InfoShare 2018‘s conference room or talking with fellow Polish programmers at Wroc#… Let’s hope these times are back soon ?

So… can online conferences replace offline ones?

In my opinion, an online conference will never replace the offline one. You cannot really create an online version of the cookies room (you know, the place where you stand between the sessions, eat cookies, drink coffee, and talk with other participants). Even if we invent some tool that would create such a room virtually (there is an option in Hopin for that called Networking, which allows to randomly talk with other participants, but I did not try that), there’s still room for technical issues. The Internet may not work for a while and all this interaction goes away. Either way, the physical contact cannot be replaced by an online call. At least not for me.

However, I noticed another interesting thing. When I used to attend offline conferences, I did not remember much from the sessions themselves. Maybe from few of them. As soon as I met someone during the break, I either started talking with them and was late for the session (or missed it completely…) or we continued to talk during the presentation. It was cool to talk, but after coming back home I did not remember much from the presentations.

With an online conference, I was able to get a lot from the sessions themselves. With the online streaming, most of the time you can also pause or rewind the video. It is extremely useful when a complex topic is described, and you need more time to analyze it (for instance a code snippet).

Another thing is that nowadays, when everything moves online, there are no alternatives to online conferences. I think this is good that we are moving such events online. The knowledge can still be shared in even more convenient and efficient way. If you want your employees to stay up-to-date with technology, online conferences might be a good choice. We do that at Yumasoft and consider it a good way for our programmers to learn and explore new technologies. However, I do hope that the offline events come back soon, so we all can have a coffee and chat in a conference room together ?

The post Can Online Conferences Replace Offline Ones? appeared first on Yumasoft.

The event was divided into 4 thematic paths:

• – NET
• – Application Architecture
• – Cloud Computing
• – JavaScript

I was mainly interested in the .Net and Application Architecture paths.

Build your software on solid foundations (Application Architecture) – Marcin Bałda

Comparison of the process of building a house to creating software. The lecture was mainly devoted to discussing SOLID principles that allow for production of high-quality software. The author focused on the importance of the application skeleton design and building solid foundations for future functionalities. The lecture was based only on theoretical issues.

Useful links:
Lecture description – in Polish
https://scotch.io/bar-talk/s-o-l-i-d-the-first-five-principles-of-object-oriented-design

REST Services with AWS Lambda and .Net Core (.NET) – Marcin Bałda

Presentation of the capabilities of the AWS Lambda platform in .NET projects. The speaker showed that .NET also works well with cloud services other than Microsoft Azure. He built a small application connecting to the AWS cloud and introduced its basic functions, such as recognizing objects in images and categorizing them using artificial intelligence.

Useful links:
https://aws.amazon.com/blogs/compute/developing-net-core-aws-lambda-functions/

Ports and Adapters (Application Architecture) – Dominik Przybysz

A very interesting lecture on ports and adapters architecture and a comparison with the layered architecture, which is currently the most widely used. Thanks to ports and adapters, we can freely change the operation of the application, and also easily scale its individual elements. This architecture also allows us to freely divide a monolithic application into microservices, as well as cooperate with various data suppliers/recipients. During the lecture, Domain Driven Design concepts and suggestions on how to model the application using the DDD approach were also addressed.

Useful links:
https://github.com/alien11689/ports-and-adapters-example
https://en.wikipedia.org/wiki/Domain-driven_design
https://herbertograca.com/2017/09/14/ports-adapters-architecture/

Secure Domain (Application Architecture) – Dominik Przybysz

The lecture was about the most common mistakes programmers make when writing code. The author presented various situations where the programmer, knowing the assumptions of e.g. Clean Architecture, misinterpreted them so that the application was built on weak foundations and thus difficult to expand in the future. The speaker also presented tools that help create better code and better define application domains.

Useful links:
Video from the conference – in Polish

History of Asynchronous in .NET – Marcin Tyborowski

During the lecture, the author presented the history of asynchronous programming in .NET and discussed the pros and cons of different approaches.

• – Thread and Threadpool – the first approach to multithreading in .NET: creating threads is very expensive and without proper control we can easily cause memory leaks
• – APM – a very non-intuitive approach, because of which multi-threaded applications have become illegible to programmers without a solid understanding of multithreading; it does not work in .NET Core
• – Event-based asynchronous pattern – a much easier approach than APM, but still the code is very different from the synchronous code
• – Task Parallel Library – thread creation is fast, adding lambda expressions has greatly increased the readability of the code, but the code is still different from the synchronous code
• – Async / await – the final version of multithreading in .NET – easy, understandable and fast

Useful links:
https://tyborowski.it/history-of-asynchronous-in-net/
https://github.com/tbr09/Multithreading

Make your applications intelligent – short tutorial how you can add artificial intelligence to your apps (.NET) – Michał Jankowski

Overview of how you can quickly turn a simple application into an application that uses artificial intelligence, based on the example of creating a photo storage program. Thanks to the Cognitive Service, the cloud automatically recognizes unauthorized photos, such as pornographic material with approximately 99% efficiency. This significantly reduces the amount of work needed to check all photos. Cognitive Services also allows you to describe photos and thus categorize them. During the presentation the lecturer created a program connecting to Cognitive Services.

Useful links:
https://www.youtube.com/watch?v=IBCqHy27ndE
https://azure.microsoft.com/en-us/services/cognitive-services/

Clean Domain Model: Domain-Driven Design tactically and practically (.NET) – Kamil Grzybek

During the presentation, the lecturer discussed how to practically implement a clean domain model using DDD and C#. The author showed many examples of how to conduct a conversation about the proper domain of the application. During the presentation it was also shown how to avoid primitive types in the program and how to write unit tests correctly for code written in this way. During the presentation, a modular monolith created with the DDD principles was presented as a counterweight to currently very popular microservices, which are also used where they do not make sense.

Useful links:
Lecture slides – in Polish
https://github.com/kgrzybek/modular-monolith-with-ddd

The post The 4DEVELOPERS Katowice 2019 conference appeared first on Yumasoft.

Last year I had the pleasure of attending the DevConf 2019 in Krakow, Poland. It was a two day IT conference with multiple lectures and presentations taking place simultaneously. It served as a great opportunity for all attendees to delve into a vast array of topics like technology or self-growth to name a few.

In this short note I would like to recommend a few interesting talks to watch at home. Here are my six picks:

“Domain Driven Design: The Good Parts” by Jimmy Bogard (link)

An interesting case study about the implementation of DDD in the Texas Juvenile Justice Department’s system. The author goes into detail about which aspects of DDD work for him and which do not in said environment.

“Six Little Lines of Fail” by Jimmy Bogard (link)

Another presentation by the same author and yet another hit. This time, Bogard focuses on possible approaches to handling errors in code with multiple operations involved (i.e. a method that writes to database and subsequently invokes external API). The author also describes existing solutions for such scenarios.

“Code the Future, Now” by Adam Ralph (link)

This presentation shows how the SAGA pattern (link) can be used to change the state of system in the future.

Some service buses (like NServiceBus) allows sending a message form SAGA class that will occur in the future (a determined time period i.e. in a week). Such event has the potential to change the state of the system with a guarantee that it will be invoked only once (eliminating the issue of changing state by introducing multiple threats/services at the same time).

In NServiceBus such a scenario can be implemented using SAGA Timeouts – (link).

If you would like to learn more then I can definitely recommend this talk.

“Feature Toggles: The Good, The Bad and The Ugly” by Andy Davies (link)

Here we can learn more about proper management of feature toggles in our code but also about the potential hazards of risky practices. This knowledge could save your company from an IT disaster. A definite must watch.

“The Art of Code” by Dylan Beattie (link)

A very entertaining presentation about the “art” of coding. Beattie demonstrates many examples of quirky code created by developers for fun and happiness of other people. A good and relaxing talk to improve your day.

“Welcome to The Machine” by Hadi Hariri (link)

Contrary to the previous suggestion, this lecture is more serious and even anxiety inducing. Hariri talks about the challenges the age of internet poses to our privacy and how big IT companies exploit our data for profit. Nowadays, we tend to divert our attention away from such issues and this presentation makes you think about the way you handle your data and with whom you share it.

The post DevConf 2019 appeared first on Yumasoft.