As a psychologist and a People & Talent officer, I’ve spent many hours trying to figure out ways in which I can make the life of the employees within IT Labs easier, more fun, and get them to be the best version of themselves – learning, creating, and becoming better every day. There are all kinds of scenarios in my head that I prepared for, but a global pandemic was definitely not one.  

This last month, we had our second health month at IT Labs, and it provided the People & Talent Department with much needed insight into what works and what doesn’t in these extraordinary circumstances – which is why I felt compelled to write this piece.  

How do you develop an activity that will be beneficial to your employees – but through a screen? How do you even approach that?  

Rethinking activities is the first thing that comes to mind, and why not? Contrasting times, different approaches, right? Well, the truth is, drastic changes are not needed, but moving on from some of the events and activities developed in the 90s – some of which are still present today – is one of them. When an activity doesn’t produce any engagement, and interest in your employees, scrap it, ASAP, otherwise you risk undermining all your efforts – once bad or bland things starts rolling out of the People & Talent departments, employees will lose interest in anything you have to offer them, and this will lead to alienation, distancing, and sooner rather than later people will not want to stay with your company anymore.  

Working remote comes with its own set of benefits, but also drawbacks – and as more people choose to work out of office, HR departments around the world will need to adjust their strategies. Does this mean throwing old plans in the bin and starting all over? Of course not, but a slight tweak and going back to basics might do the trick.  

The core of the issue lies in the drawbacks that come with working remote: lack of community and team spirit, more distractions, lack of motivation, risk of burnout.  

So how can we help ease these and ensure employees are at their best? By giving them the main thing that’s missing in their work – a human moment. Yes, as leaders of People & Talent departments it’s our duty to stay in touch with everyone and check in on them every now and then, but how do we make it in a way that makes a difference? By having an open, heart to heart conversation with every single person. Poke and prod, spend 15-20 minutes to talk about all matters work and life related, show interest in their life, and of course, provide support and assure them that you are here for them to talk about any subject and matter that bothers them – a pure human moment can do a world of good for anyone struggling with alienation, isolation, and the ‘new normal’. 

The point is, we have an obligation to keep things professional, but that doesn’t mean we can’t lend a hand to anyone in need, especially in our work environment – it’s not our job, it’s our duty.  

Circumstances can and will change, environments will change, people will change – but the one thing that shouldn’t change is our desire to be the best versions of ourselves, by enabling and motivating others to be the best themselves. 

There’s new tech, new ways of doing stuff, new platforms, new toys – but the debate regarding specializing or sticking to a jack-of-all-trades style is still ongoing. Now, before anyone gets excited, I’m not here to put it to bed – I’m here to add more oil to the fire. 

Just kidding – I simply believe that the perspective is way too simplistic than the reality. Of course, there’s the need for both, and yes, sometimes techies, leaders, and tech leaders can do both, depending on the project. There is no such thing as one-size-fits-all in the world of technology.  

As I’ve been in this line of work as a BA for more than a decade now, I also have experience as a Product and Project Manager, and I think it’s time I shared my two cents on the matter. I will not preach, nor give you a recipe for success – I’ll just write about what I’ve learned in the world of tech, regarding that title above.  

No more, no less. 

Knowing How to Approach Problems

Approaching IT problems is all about perspectives, and the more diverse your skill set, the easier it will be to see the pain points of a project. This isn’t just about planning and execution; this is also about setting up the project in which your team can be not just effective, but also learn and connect. 

I’ve learned things I never thought I’d have the chance to use, but you’d be amazed how something you consider irrelevant or impractical can actually be your rescue when facing complex problems. 

Furthermore, this helps add another dimension to the way you’re leading teams, and helps with delegating! Sure, knowing the core of the matter and having a sense of it is always nice, but why not use this knowledge and put it to something like nurturing. You can measure out your approach – go with passive listening and guide your team with questions, or you can engage and guide by doing. The correct way? Take a look at your team, and you’ll know – what they need and how they work will give you the answer right away. 

Working as a BA, product manager, and sometimes project manager, this can be achieved if one is ready to walk that thin line between having a front-row view of the project, and looking at it from the side – a mix of objectivity and subjectivity. 

Flexibility

I know, I know, it’s something that’s talked about a lot. But I’m here to talk about the flexibility towards clients. Agile is a methodology that is applied to teams working on the project, but can it be applied to clients? Yes, and to a great extent. 

Sometimes, behind a project you have one client, and sometimes there are multiple stakeholders. All this can present a challenge, as there are multiple ideas about how to conceptualize and execute the development process, and sometimes these can be conflicting. For this, specializing comes to the rescue. 

Having something as a specialty can help you not just with understanding the project and envisaging it, but also help you convey your messages and recommendations to the client. Simple, short explanations that will help the client understand what you’re trying to achieve, and visualize your proposed changes and additions. 

And at the core of this lies the relationship you form with your clients – sometimes you might click, at other times you’ll need to engage: ask questions, ask explanations – whatever it takes for you to get a better understanding where the client is coming from. 

Mutual understanding lies at the heart of client satisfaction. 

Before the car was a car or the iPhone was an iPhone, it was an idea. So, everything manmade comes from the idea, which is based on a need or improvement, but yes – the idea is the foundation for anything related to innovation. But, the word idea to a lot of people sounds intimidating. Not in the sense that they cannot come up with one, but because of the socially applied pressure that only good ideas need to be heard – thus instantly placing their idea on hold. And the objective truth is that every idea is good at some point in time, the real question is if the time for that idea has come. 

On ideas and all things related, we sat down with Blagoj Kjupev, our Chief Innovation Officer, and talked about ideas, how to spot a good one, how to unearth them, and why engaging your teams to voice ideas is important. 

ITL: What makes an idea a good one?  

Blagoj:  The person giving the idea and the people listening to that idea. That’s it, there must be a good match. An idea in itself cannot be good or bad. It’s the room that the idea is presented in, figuratively speaking of course. Somebody’s bad idea can be someone else’s spark into an amazing adventure ending with a very successful product or service. Think of anything produced and developed by humans. How much of that was a complete, producible idea in its inception? If I had to guess it’s in the 0.00 margins. This means that on each idea an additional work has to be conducted to have it fully developed and understood by investors and companions that will help in its development.   

Ideas are an amalgamation of all our experiences, references to things we’ve seen, read, watched, listened to... When a problem is presented, our mind unconsciously goes through all of that and finds an approach to help us solve the problem. So, we all have ideas, every day. It’s just that most stay silent and undeveloped due to different reasons. Our focus during the incoming period will be to help our colleagues feel comfortable expressing and develop their ideas.   

ITL: So, ideas need to be voiced more often. As the Chief Innovation Officer at IT Labs, how will you change that?  

Blagoj: : After many discussions with my colleagues from the marketing and other departments, my expectations were confirmed that we have the manpower, know-how, and creativity in our teams to take ideas and turn them into real-life projects and products. We’ll further increase the number of activities that are taking place, to include brainstorming and open discussion events in which we’ll speak about solving already identified problems, existing solutions, new technological breakthroughs, and develop ideas that might turn into something amazing.  

ITL: Okay, we all have ideas, right? How do you decide which ones are worthy of being considered? How do you separate the “hmmm, that might work” from the “that’s just crazy”?  

Blagoj: Via open discussions and for some areas by having a guest who is great in specific areas of expertise which is touching the idea. Sometimes from one idea, there will be more ideas emerging, sometimes we’ll together with the author decide that the time is not right for that idea. Only through open discussions and brainstorming we can reach a common understanding of the real value of any idea and agree on next steps.  

The invisible pink elephant in the room – with the world at a standstill, how do I keep growing? How do I find the pockets of space, time, and energy to maintain my learning curve?

I didn’t just drown into all the material available on the web. Because learning opportunities don’t just come in the shape of courses, meetings, feedback sessions, webinars, and workshops – it’s about making the space for it.

Making the time and space to learn and develop as a project manager sounds impossible, right? But it isn’t. I set about delegating tasks and responsibilities to willing team members with the goal of enabling them to grow into their roles. I was then left with pockets of time and space in which I was free to do develop.

This was somewhat unexpected, but then it hit me – ‘you need to give in order to receive’ – an adage as old as time itself resonating in extraordinary times. This all led me to a simple conclusion – the circumstances have changed, but our values and principles need not. We still need to do what we’ve always been doing. It’s just the shape and this uncomfortable feeling around it all that somehow paints it all black.

Dear Project Managers, keep diving into your leadership and team-growing methods.

Even with all the tips and tricks, the structure, the awareness, the leading, things will go sideways from time to time. Your team(s) will suffer from dips in motivation and creativity, and sometimes will struggle – and the same can happen to you.

And then, there’s the worst-case scenario – you’re having a rough day, and a member of your team is going through something as well. When I first got in this kind of situation, I was literally at loss for words – and action! I was unable to even comprehend what was happening, and had no idea how to resolve this. I didn’t have the person in front of me, that direct, tete-a-tete moment was lacking, and I was unable to even get out of my own difficult situations.

After winging it a few times I realized that the thing that will work time and time again is to have a purely human moment. Listen, reflect, share, offer support, and make the necessary steps you believe need to be taken to come to a resolution. And of course, assurance. Don’t forget that this void of activity is affecting everyone, and that sometimes team members just need to know that it’s okay for them to take a break and reflect.

Showing understanding is one thing, acting on it is the hard part – that’s what will help you keep your team happy, and bring solidity in these times of uncertainty.

ITL: IT Labs has been in the tech industry since 2005. Where were you then – and where are you now as a company? Where is IT Labs positioned at the moment in the world of software development?

Nina: Since IT Labs’ beginning 15 years ago, we’ve been cooperating with companies and businesses from various industries, located around the world. We started off with smaller projects and smaller teams, but over time, we developed our portfolio in several sectors and areas, and this allowed us to grow and expand as a company. As we rose through the ranks, we quickly became the main driver in the digital transformation of our partners. Now, we offer wide-spectrum products and services: from advising and consulting on business strategies, all the way to managing a full software-development process and cycle, including maintenance and support.

After opening our first dev hub and establishing and got a foothold in the market, we proceeded with expanding in the Americas, Western and Eastern Europe, covering business centers in the USA, UK, and the Netherlands. We have just opened an office in Serbia, since we identified that it has a strong IT capacity and a very developed business culture that will help us diversify, grow, and develop as a company.

ITL: What kind of clients do you work with? What kind of services do you offer them?

Nina: We offer a wide array of services, from deploying business agility to defining business strategies. Specifically, services regarding business analysis, product architecture, development, testing, DevOps, and cloud strategy. These include security services, which come in handy for clients with partial or non-existent coverage in this area. Our experts analyze security systems and their structures, and develop client-specific strategies.

With tech development and changes in the market, the services we offer also diversified and expanded, so now, we also offer AI and data science-related services as well. We have a team of experts in data analysis, data science, and AI who can transform clients’ product revenues by optimizing data flows and data analysis. Thus, leading the client with data that serves their unique position in the market. What sets us apart from the competition is the fact that we don’t just offer technical services. We offer highly skilled and professional teams which have worked on big projects, their success was measurable and tangible, and have helped clients develop and grow. There’s no need for the client to waste time and energy in putting together and nurturing teams to carry out tasks in various departments. We do all this for them, and then some. Our teams of professionals are focused on exceeding the expectations of the client, and we achieve this by treating people as the most valuable asset. We can guarantee quality in delivery and efficiency for our clients.

ITL: It’s in the nature of every business to grow and expand. Is that true for IT Labs?

Nina: We’ve been growing and expanding for a while now, with our next growth steps in Serbia. For us, it’s one of the main IT centers in the Balkans with a huge pool of skilled and experienced techies, and an excellent education system developing great IT engineers.

We’re extremely happy to be expanding there since it’s a country that has one of the biggest development hubs in the region. All the hubs in the region have many similarities and connections, so it will be a fun ride and a strong challenge for us.

ITL: Do you think that IT Labs can go head-to-head with a market such as the Serbian one? What does the company have to offer to the Serbian IT crowd?

Nina: Of course we can. We’ve done it before, and we’ve learned that the best way to approaching a new market does not differ in its essence from any other task you set out to do. Honesty and commitment are the best tools we have, and these will help us in networking with the local relevant entities, show support where needed, work with local startups and educational institutions, and just nest ourselves as best as we can.

We are confident that the Serbian IT crowd will recognize that we are a trustworthy partner, a great employer, and overall a benefit to the local IT community. IT Labs cares for each employee’s professional and personal goals, irrespective of the position or seniority, and I trust that approach will be highly appreciated by anyone who decides to become a part of our team.

ITL: Is there room to grow in the company? Do employees get a chance to reach for their personal goals and achievements?

Nina: Growth is a natural process, right? It doesn’t make sense, nor is right, for the employees to not develop and grow parallel with the company. To us, the personal and professional growth of every individual is very important. It’s one of the key reasons why we encourage, stimulate, and enable this for every employee in every department.  We have an internal project called ‘The Happiness Strategy’, focused on finding the “needs & wants” of the people, and then engages in working towards them. Every person is unique in their needs and wants, and diversity in needs translates to diversity in quality, which in turn breeds innovation. It’s simple, really – give people support and the chance to express, and your teams will be better, stronger, and more efficient.

ITL: You told us about the past and the present. Where do you see the company in the future?

Nina: Bigger. Better. Stronger. That’s what we strive for. Hard  work and dedication will be needed to get there, but considering how we’ve paved the way so far with the whole team, I know that in five years’ time, we’ll look back knowing we’ve achieved all our goals, and surpassed expectations. Bottom line is, we know what we need to do – keep developing and expanding this happy, diverse, innovation-driven bunch of people working here, and help them achieve their personal and professional goals in a friendly and radically-transparent environment!

Blazor is open-source cross-platform framework that lets you build interactive web UIs using C# instead of JavaScript. Blazor apps are composed of reusable web UI components implemented using C#, HTML, and CSS. Both client and server code is written in C#, allowing you to share code and libraries.

The .NET code runs inside the context of WebAssembly, running “a .NET” inside the browser on the client-side with no plugins, no Silverlight, Java, Flash, just open web standards. Blazor works in all modern web browsers, including mobile browsers. Code running in the browser executes in the same security sandbox as JavaScript frameworks. Blazor code executing on the server has the flexibility to do anything you would normally do on the server, such as connecting directly to a database.

Blazor has a separation between how it calculates UI changes (app/component model) and how those changes are applied (renderer). This sets Blazor apart from other UI frameworks such as Angular or ReactJS/React Native that can only create web technology based UIs. By using different renderers Blazor is able to create not only web based UIs, but also native mobile UIs as well. This does require components to be authored differently, so components written for web renderers can’t be used with native mobile renderers. However, the programming model is the same. Meaning once developers are familiar with it, they can create UIs using any renderer.

Blazor server-side and WebAssembly are both now shipping as part of .NET Core 3.2.0. Installing Blazor is now as simple as installing version 16.6 or later of Visual Studio, when installing, ensure you select the option ASP.NET and web development under the Workloads tab.

Blazor is a web framework designed to run client-side in the browser on a WebAssembly-based .NET runtime (Blazor WebAssembly) or server-side in ASP.NET Core (Blazor Server). Regardless of the hosting model, the app and component models are the same.

The client-side version actually runs in the browser through Wasm and updates to the DOM are done there, while the server-side model retains a model of the DOM on the server and transmits diffs back and forth between the browser and the server using a SignalR pipeline.

Server-side hosting was released in September 2019, and Web Assembly was officially released in May, 2020.

In January 2020, Microsoft announced Blazor Mobile Bindings, an experimental project that allows developers to build native mobile apps using a combination of Blazor and a Razor variant of Xamarin.Forms (XAML).

On the client, the blazor.server.js script establishes the SignalR connection with the server. The script is served to the client-side app from an embedded resource in the ASP.NET Core shared framework. The client-side app is responsible for persisting and restoring app state as required.

With the Blazor Server hosting model, the app is executed on the server from within an ASP.NET Core app. UI updates, event handling, and JavaScript calls are handled over a SignalR connection.

In Blazor Server apps, the components run on the server instead of client-side in the browser. UI events that occur in the browser are sent to the server over a real-time connection. The events are dispatched to the correct component instances. The components render, and the calculated UI diff is serialized and sent to the browser where it’s applied to the DOM.

In this diagram from the docs you can see that the Razor Components are running on the Server and SignalR (over Web Sockets, etc) is remoting them and updating the DOM on the client. This doesn’t require Web Assembly on the client, the .NET code runs in the .NET Core CLR (Common Language Runtime) and has full compatibility – you can do anything you’d like as you are no longer limited by the browser’s sandbox.

This is the hosting model that usually gets most interest, and for good reason. This model is a direct competitor to JavaScript SPAs such as Angular, VueJS, and React. Blazor WebAssembly apps execute directly in the browser on a WebAssembly-based .NET runtime. Blazor WebAssembly apps function in a similar way to front-end JavaScript frameworks like Angular or React. However, instead of writing JavaScript you write C#.

The .NET runtime is downloaded with the app along with the app assembly and any required dependencies. No browser plugins or extensions are required. The downloaded assemblies are normal .NET assemblies, like you would use in any other .NET app. Because the runtime supports .NET Standard, you can use existing .NET Standard libraries with your Blazor WebAssembly app. However, these assemblies will still execute in the browser security sandbox. A Blazor WebAssembly app can run entirely on the client without a connection to the server or we can optionally configure it to interact with the server using web API calls or SignalR.

Blazor apps are built using components. A component is a self-contained chunk of user interface (UI), such as a page, dialog, or form. A component includes HTML markup and the processing logic required to inject data or respond to UI events. Components are flexible and lightweight. They can be nested, reused, and shared among projects. Components are implemented in Razor component files (.razor) using a combination of C# and HTML markup. A component in Blazor is formally referred to as a Razor component. ​
​​
Most files in Blazor projects are .razor files. Razor is a templating language based on HTML and C# that is used to dynamically generate web UI. The .razor files define components that make up the UI of the app. For the most part, the components are identical for both the Blazor Server and Blazor WebAssembly apps. Components in Blazor are analogous to user controls in ASP.NET Web Forms.

Each Razor component file is compiled into a .NET class when the project is built. The generated class captures the component’s state, rendering logic, lifecycle methods, event handlers, and other logic. When the application is compiled, the HTML and C# code converted into a component class. The name of the generated class matches the name of the component file. A component file name must start with an uppercase character. If you add a component file that starts with a lower case character, the code will fail to compile and you get the following compiler error.

All rendered Blazor views descend from the ComponentBase class, this includes Layouts, Pages, and also Components. A Blazor page is essentially a component with a @page directive that specifies the URL the browser must navigate to in order for it to be rendered. In fact, if we compare the generated code for a component and a page there is very little difference.

Aside from normal HTML, components can also use other components as part of their rendering logic. The syntax for using a component in Razor is similar to using a user control in an ASP.NET Web Forms app. Components are specified using an element tag that matches the type name of the component.

Blazor provide an event-based programming model for handling UI events. Examples of such events include button clicks and text input. In ASP.NET Web Forms, you use HTML server controls to handle UI events exposed by the DOM, or you can handle events exposed by web server controls. The events are surfaced on the server through form post-back requests.

In Blazor, you can register handlers for DOM UI events directly using directive attributes of the form @on{event}. The {event} placeholder represents the name of the event.
​​
Event handlers can execute synchronously or asynchronously. After an event is handled, the component is rendered to account for any component state changes. With asynchronous event handlers, the component is rendered immediately after the handler execution completes. The component is rendered again after the asynchronous Task completes. This asynchronous execution mode provides an opportunity to render some appropriate UI while the asynchronous Task is still in progress.

Components can also define their own events by defining a component parameter of type EventCallback<TValue>. Event callbacks support all the variations of DOM UI event handlers: optional arguments, synchronous or asynchronous, method groups, or lambda expressions.

Blazor provides a simple mechanism to bind data from a UI component to the component’s state. This approach differs from the features in ASP.NET Web Forms for binding data from data sources to UI controls.

One-way binding

One-way data binding is also known as an interpolation in other frameworks, such as Angular. It have a unidirectional flow, meaning that updates to the value only flow one way. It is very similar to Razor and also it will be quite straightforward. In one-way binding, we need to pass property or variable name along with @.

In Blazor, when modifying a one way binding the application is going to be responsible for making the change. This could be in response to user action or event such as a button click. The point being, that the user will never be able to modify the value directly, hence one way binding.

Two-way binding

Blazor also supports two-way data binding by using bind attribute. The primary use case for two way binding is in forms, although it can be used anywhere that an application requires input from the user.

Razor rewrites the @bind directive to set the property Value and add an event handler for ValueChanged. Setting Value defines the original value for the child component. When the value is changed in the child component, it notifies the parent using the ValueChanged callback. The parent component can update the value of the Age property.

In Blazor, each page in the app is a component, typically defined in a .razor file, with one or more specified routes. To create a page in Blazor, create a component and add the @page Razor directive to specify the route for the component. The @page directive takes a single parameter, which is the route template to add to that component.

The route template parameter is required and are specified in the template using braces. Blazor will bind route values to component parameters with the same name (case-insensitive).

Components in Blazor, including pages, can’t render <script> tags. This rendering restriction exists because <script> tags get loaded once and then can’t be changed. Unexpected behavior may occur if you try to render the tags dynamically using Razor syntax. Instead, all <script> tags should be added to the app’s host page.

A Blazor layout is similar to the ASP Webforms concept of a Master Page, and the same as a Razor layout in ASP MVC.

In Blazor, you handle page layout using layout components. Layout components inherit from LayoutComponentBase, which defines a single Body property of type RenderFragment, which can be used to render the contents of the page. When the page with a layout is rendered, the page is rendered within the contents of the specified layout at the location where the layout renders its Body property. You can specify the layout for all components in a folder and subfolders using an _Imports.razor file. You can also specify a default layout for all your pages using the Router component.

When specifying a @layout (either explicitly or through a _Imports.razor file), Blazor will decorate the generated target class with a LayoutAttribute. Blazor will honour a LayoutAttribute on any ComponentBase descendant. Not only do pages descend from this class, but the LayoutComponentBase does too! This means that a custom layout can also have its own parent layout.

Layouts in Blazor don’t typically define the root HTML elements for a page (<html>, <body>, <head>, and so on). The root HTML elements are instead defined in a Blazor app’s host page, which is used to render the initial HTML content for the app (see Bootstrap Blazor). The host page can render multiple root components for the app with surrounding markup. ​

Routing in Blazor is handled by the Router component. The Router component is typically used in the app’s root component (App.razor). The Router component discovers the routable components in the specified AppAssembly and in the optionally specified AdditionalAssemblies. When the browser navigates, the Router intercepts the navigation and renders the contents of its Found parameter with the extracted RouteData if a route matches the address, otherwise the Router renders its NotFound parameter. The RouteView component handles rendering the matched component specified by the RouteData with its layout if it has one. If the matched component doesn’t have a layout, then the optionally specified DefaultLayout is used.

Routing mostly happens client-side without involving a specific server request. The browser first makes a request to the root address of the app. A root Router component in the Blazor app then handles intercepting navigation requests and them to the correct component. Blazor also supports deep linking. Deep linking occurs when the browser makes a request to a specific route other than the root of the app. Requests for deep links sent to the server are routed to the Blazor app, which then routes the request client-side to the correct component.

For the best possible user experience, it’s important to provide a consistent experience to the end user when their connection is temporarily lost and when they refresh or navigate back to the page. The components of this experience include:

• The HTML Document Object Model (DOM) that represents the user interface (UI)
• The fields and properties representing the data being input and/or output on the page
• The state of registered services that are running as part of code for the page

In the absence of any special code, state is maintained in two places depending on the Blazor hosting model. For Blazor WebAssembly (client-side) apps, state is held in browser memory until the user refreshes or navigates away from the page. In Blazor Server apps, state is held in special “buckets” allocated to each client session known as circuits. These circuits can lose state when they time out after a disconnection and may be obliterated even during an active connection when the server is under memory pressure. ​

Generally, maintain state across browser sessions where users are actively creating data, not simply reading data that already exists. To preserve state across browser sessions, the app must persist the data to some other storage location than the browser’s memory. State persistence isn’t automatic. You must take steps when developing the app to implement stateful data persistence.

Data persistence is typically only required for high-value state that users expended effort to create. In the following examples, persisting state either saves time or aids in commercial activities:

Multi-step web forms: It’s time-consuming for a user to re-enter data for several completed steps of a multi-step web form if their state is lost. A user loses state in this scenario if they navigate away from the form and return later.

Shopping carts: Any commercially important component of an app that represents potential revenue can be maintained. A user who loses their state, and thus their shopping cart, may purchase fewer products or services when they return to the site later.

An app can only persist app state. UIs can’t be persisted, such as component instances and their render trees. Components and render trees aren’t generally serializable. To persist UI state, such as the expanded nodes of a tree view control, the app must use custom code to model the behavior of the UI state as serializable app state. ​

Dependency injection is a best-practice software development technique for ensuring classes remain loosely coupled and making unit testing easier. The Blazor supports Dependency injection in both the Blazor server and Blazor WebAssembly app. The Blazor provides built-in services, and you can also build a custom service and use it with a component by injecting them via DI.

A Blazor app can invoke JavaScript functions from .NET methods and .NET methods from JavaScript functions. These scenarios are called JavaScript interoperability (JS interop). JavaScript should be added into either /Pages/_Host.cshtml in Server-side Blazor apps, or in wwwroot/index.html for Web Assembly Blazor apps. Our JavaScript can then be invoked from Blazor by injecting the IJSRuntime service into our component.

To call into JavaScript from .NET, use the IJSRuntime abstraction. To issue JS interop calls, inject the IJSRuntime abstraction in your component. InvokeAsync takes an identifier for the JavaScript function that you wish to invoke along with any number of JSON-serializable arguments. The function identifier is relative to the global scope (window). If you wish to call window.someScope.someFunction, the identifier is someScope.someFunction. There’s no need to register the function before it’s called. The return type T must also be JSON serializable. T should match the .NET type that best maps to the JSON type returned.

For Blazor Server apps with prerendering enabled, calling into JavaScript isn’t possible during the initial prerendering. JavaScript interop calls must be deferred until after the connection with the browser is established. ​

• https://docs.microsoft.com/en-us/dotnet/architecture/blazor-for-web-forms-developers/introduction  ​
• https://blazor-university.com/ 
• https://www.pragimtech.com/blog/blazor/what-is-blazor/  ​
• ​https://docs.microsoft.com/en-us/aspnet/core/blazor/?view=aspnetcore-5.0  
• ​https://github.com/AdrienTorris/awesome-blazor  
• https://github.com/SteveSandersonMS  
• https://www.youtube.com/user/IAmTimCorey/search?query=blazor  ​​
• www. youtube.com/playlist?list=PLSIKM6F-xklKaf0lPlphuIqZgZrmWhmfj
• https://www. youtube.com/watch?v=zjlUstW7ISU
• https://www.youtube.com/c/CuriousDrive/playlists 
• https://blazor-tutorial.net/ 
• https://www.youtube.com/watch?v=zjlUstW7ISU ​
• https://jonhilton.net/blazor-state-management/ ​
• ​https://blog.jeremylikness.com/blog/blazor-state-management/ 

In our company, high-performing teams are essential in achieving excellence in software development. A software’s performance on the other side, is built on good specifications & project requirements and BAs have their crucial role in defining them. Their task is to collect specifications from all stakeholders to ensure that the proposed software solution meets all of their requirements. Working on the requirements is a model that is built a bit ahead from the development with customer’s consent and active participation in the requirements elicitation phase. BAs work in advance on the scope definition on a project or on a sprint level, presenting them the business scope to the development team that is about to start working on the implementation. So, what does BAs have to do with QAs? The answer is simple: ensuring the solution meets the business requirements! They both test the workable pieces of software that are deployed as well as the final product making sure there is a match between the client’s expectations & needs and the actual result which is about to be delivered on the other side (BA side) and that what delivered to the customer corresponds to what defined in the business requirements documentation (QA side). Although there seem to be two different sides of the story or better said, different approaches to the same thing, still the purpose is the same: making sure that a high-quality software is developed according to the business requirements from the customer.

The most important step in solving every problem is to test the proposed solution. As a result, the tested outcomes are seen as a critical project success factor. We must first consider how “testing” fits into the overall picture of device creation lifecycles before we can begin dissecting it. Understanding the business logic means understanding the software’s requirements. As such, when gathering them and during the requirements elicitation phase, we as BAs need to know what good requirements are. Among their correctness, feasibility, clearness, and unambiguity, making sure that every requirement meets a specific business need that can be tested is crucial and it requires a specific criterion against which it can be validated. Requirements meeting the acceptance criteria are essential in avoiding conflicts between the stakeholders or unhappy customers. It turns out that acceptance criteria are kind of an agreement between all the parties. For instance, let’s consider the following requirement: “The system shall be user-friendly”. Fancy as it may sound, the aforementioned statement does not provide a clear and verifiable criterion of what user-friendliness is. We would not know whether to “pass” or “fail” this requirement simply because we miss the criteria against which we can test it! Instead of it, during the elicitation of this requirement, we could establish that the system will provide help screens, dialog boxes, easy menu-driven navigation, etc. Having this in mind, we can understand how important it is for all requirements to be testable.

Software testing happens at several stages during the implementation of a project. In some of them, the Business Analyst is directly involved, while in others, they are available to clarify requirements.

During the integration testing, BAs act as support here providing guidance and answering questions that the developers may have.

Having this in mind, both BA and QA will work together to define test scenarios. Inconsistencies between the views expressed by the functional specifications, templates, and tests can result from ambiguous user requirements and differing interpretations. While developers convert specifications into the user interface and technological designs, BAs and QAs work together on transforming conceptual requirements into verifiable test scenarios and procedures.

As we can see in the above diagram, testing the business requirements requires a common approach both from the BAs and the QAs.

Following up the previously mentioned example diagram, here is how a test example would look like. The testing process combines a common understanding of the business requirements.

In the aforementioned example, a use case would be “checking/finding an already made reservation”. The path included in this process allows the users to search through a certain database where the specific reservation is stored.

• The end-user enters the previously received confirmation number in a reservation search system.
• The system offers a search field from where the end-user will be able to find the reservation or make a new one.

• If the system contains the searched reservation, then it should display it.
• The user shall select to open the found reservation, if any, or create a new one.

Based on the diagram, we can see that the abovementioned use case has several possible execution paths, therefore it makes sense to compose several test plans, especially if we keep in mind the exceptions. At this point, usually, BA tests are more on a high level because they intent to cover the business logic scenarios. As we move with the development phase, QAs will work on making more specific test cases including all aspects of both positive and negative scenarios. Testing these requirements means making sure execution is possible by going through every requirement. The easiest way for both BAs and QAs is to visually draw an execution line that will make obvious the incorrect or the missing part, so the process can be improved, and the test refined. This way of approaching the testing and the combined effort between the BAs and the QAs allows to avoid missing parts or to remove redundant requirements before a code is written.

Although a joint effort is required, still BAs gather the requirements first. Since assigned project testers are seldom present during the gathering of business specifications, test data must be produced and recorded consistently for the assigned testers. This strategy would make it easier for testers to complete their assignments and for business analysts and project managers to coordinate such research. In reality, before a QA joins the team, BAs need to collaborate with the tech people on the project to develop the test scenarios ensuring their validity and traceability before they are provided to the dedicated QAs. This way, they don’t need to revalidate test data that do not correspond with the exact business requirements.  Although testing is something that BAs and QAs have in common, yet there is one crucial difference: UAT primary purpose is to define that the system fits the business logic and that it serves both the customer and the end-users, while the system testing purpose is to make sure the software behaves the way it is supposed to according to the defined business requirements. In the end, we can just confirm that good software is based on a collaborative approach of all involved parties in its development cycle, while conceptual testing remains a powerful way for discovering requirements gaps and ambiguities and solve them!

Daniela Zdravkovska

Business Analyst
June 2021

Risto Ristov

Project Coordinator & Content Editor

People are not used to the topics of creativity and business in the same conversation. A lot of people out there believe that business is purely financial and about making money, while creativity is more of an artistic value. Yes, an artist should be creative and share creativity with the world, but so should a software engineer in order to build rational and sustainable solutions, a mathematician to solve the hardest math problem , a salesperson to attract perspective clients, or a CEO to lead a company in the right direction.

Creativity is a crucial factor in today’s business environment because it represents a way of thinking that can inspire, challenge, help people to solve existing problems and find innovative solutions. It’s the source of inspiration and innovation. Simply put, it is solving problems in original ways.

There is no business or project that had great success without any creative or innovative ideas being implemented. Creativity is one of the most important reasons why businesses can thrive in a world of “big” technology-sustainable ideas. In today’s challenging and groundbreaking technology market, creative business ideas set companies apart from one another. Without creativity, we might be going around in circles and doing the same things, over and over again. What kind of a fun world and competition would that be? Where would progress be? What would set us apart?

Top 10 skills

The World Economic Forum placed creativity in top 3 required skills to run a business in 2020.

Source: Future of Jobs Report, World Economic Forum

In 2015, creativity was in the top ten skills but it was placed in 10th place. In 2020, the World Economic Forum placed it in 3rd place. According to their research, more companies are starting to realize how important creativity is to their overall business success.
What does creativity brings to a business?

• Competitiveness
• Improves company culture
• Increases productivity
• Solves problems
• Brings Innovative solutions that can change the world

Every company tries to grow and expand while surpassing the competition. It is crucial to bring some new ideas, something different, something helpful to your customers in order to achieve greater value. If you simply copy what other businesses do, you can’t expect to become the best in the industry. You need to innovate, come up with the best rational solutions, and push the boundaries of what is really possible out there.

A major benefit of creativity is that it helps boost productivity. It will bring a feeling of belonging, a feeling of creating something new, something innovative. It will make people feel appreciated, and with that kind of motivation at hand, we can expect for them to surpass the limits and the expectations. This doesn’t mean that people are not susceptible to make mistakes, but it means that when mistakes happen, it will be easier to accept them and understand feedback about it at the highest level.
Despite what you have thought before, creativity is a skill. And just like other skills, it can be developed and nurtured if everyone works on it.

In the very end, I will say this, step out of your comfort zone, explore new solutions, and stimulate creativity. The world is up to you to change it. Dream big because in terms of technology, anything is possible if we just get our minds into it.

Risto Ristov
Project Coordinator & Content Editor
May 2021