Dear UI Engineer,
To be able to ship web applications reliably, consistently and confidently is the pinnacle of what we aspire to do. It is not only why we are paid, but it makes us fulfilled as professionals too!
But… I KNOW, you get frustrated because as your codebase grows your UI architecture doesn’t.
Maybe you have implemented all the shiny UI frameworks like React, Angular or Vue. Or perhaps you reached out to libraries like Redux and RXJS to help you manage your state. Maybe you have begun writing complex end-2-end tests in whatever test framework is the _flavour_of_the_month_.
Sadly, these things were meant to help you but they haven’t…
Because your code is turning into a jumbled mish-mash that makes you feel queasy.
You MUST know what I am talking about … right?
That slow anxious feeling that comes up in your gut because your code and its structure is becoming more complex and MORE difficult to work with as time goes on. Instead of becoming EASIER.
Perhaps… this is you?
The thing is… a professional UI developer should NOT be having these problems.
They SHOULD have the ability to consistently grow, scale and test a significantly large codebase. With maintainability, scalability and high-quality code no matter how big it gets.
But… the sad fact is many of us just haven’t figured out how to do this… yet!
We keep focussing on all these fancy ‘UI frameworks’ and these tools only to be let down time and time again at the sight of our own confused and sprawling codebases!
“He Who Chases Two Rabbits Catches None” – Confucius
Well, never fear my engineering friend … this is going to change!
You could follow a proven process that would help you become a UI Architect by learning to leverage the deep relationship between architecture and testability.
In a way that… brings you pleasure not PAIN?
All of these things are what a good UI architect can do! Being a UI architect is a skill, and like all skills… they can be learned!
My name is Pete Heard; I am the founder of Logic Room a REAL consulting and training company based in Reading, UK.
At Logic Room we help engineers transform their careers by teaching them how to break down complex engineering problems using simple and repeatable processes.
Let me tell you how it started...
It was 2014 and I got a new gig as a consultant engineer; I was ‘told’ by the manager interviewing me that his team was building a complex UI app and had the cleanest code!
I excitedly joined the project but within days I realised his team had BIG problems…
I quickly found out the engineers WERE doing all the right things technically. However they were all complaining that their architecture was confusing and their testing efforts were getting worse over time not better. NONE of them were happy with the results!
There is nothing that annoys me more than seeing intelligent engineers who cannot connect with their work. So … I decided to fix this problem…
I realised that the one main problem that they seemed to have was that their approach to development and code structure varied wildly between each engineer.
Some of them were writing unit tests to prove their code instead of writing end-2-end tests. Some of them were using object-oriented approaches some of them using functional. Some of them were using several data models in their architecture while some were using none.
It was a patchwork of different conceptual approaches that nobody seemed to agree on. I realised what this team needed was a methodology that would holistically let them build, architect AND test their code in one simple process. This ‘guard-rails’ technique would NOT focus on UI frameworks but instead on architecture, because by removing the UI framework from the architecture we would give total control to the engineers.
I began documenting a blueprint and approach for this team and we IMMEDIATELY got spectacular results. Because it was giving everyone the same basic philosophy and foundation to work from. We were able to suddenly all start communicating and architecting our code and tests in a consistent and simple way!
I have spent many years since that project refining this blueprint, and today this is what I want to talk to you about...
I have never met an engineer who's told me they are truly happy with their ability to grow code consistently - no matter how large the codebase gets.
What do you want from your career?
Do you want to keep pretending that you like testing when really you think it sucks?
Would you like to be able to do work YOU LOVE? At the speed you NEED TO?
It IS possible to grow your apps reliably.
The problem is; everyone keeps teaching you the detail and technicality of tooling and frameworks instead of the ‘PHILOSOPHY' of architecture and testability.
RIGHT NOW, before you my fellow engineer…
You have the OPPORTUNITY to purchase from me the exact method, blueprint and APPROACH that I have developed which will….
GUARANTEE … that WHEN you build your UI apps you can do it consistently, long term, with fluidity and with grace. But most importantly… happily!
Today I am excited to present our FLAGSHIP training course called the '12-Week UI Architecture Academy'.
Here is why it's special...
Most front-end training on the market presents you with trivial approaches which do not help you grow your code, because they take you down the wrong path from day one.
They give bad advice because they force you to follow the UI framework (React, Angular or Vue etc).
And because of this you have the frameworks opinion FORCED on you which means you are not in control.
These 'traditional' approaches significantly slow you down because you end up spending too much time focussing on the WRONG things.
In our ‘UI Architecture Academy’ we do things differently.
We show you how to focus on the RIGHT things, in the right way and avoid being forced to follow the frameworks.
We do this because we want to show you what a good architect does...
Because they apply architectural rules as they build their apps, they will always apply a thinking first paradigm not a framework or technology first one.
This is because architecture isn’t about technology, it’s about the human brain, specifically how we understand the problem not how the framework understands it.
When we focus on our brain to build code like this it has two monumental advantages.
Firstly, the architecture stays simple enough to understand.
Secondly, the code will always be easier to test.
By following an architectural first approach you will see that we can keep refining our code. This means that when we need to maintain and test it, we can. No matter how complicated it gets. This is the exact approach that I started introducing into that team all those years ago.
The way we have designed the course is to take all the knowledge you could learn from books, blogs, gurus and training. Then we have stripped out the parts you actually need, and dumped the parts you don’t.
In our training you will find the right parts from the following topics and sources…
We wrap it up and explain it in the right way. In one holistic system which lets you learn and apply in an efficient manner, instead of struggling to figure it out alone - like I had to!
The course is delivered with 4 elemental building blocks;
Over the course of 12 weeks, we deliver you 12 modules which together are going to accelerate you from a simple framework engineer to an architect engineer.
The entire 12-week programme consists of two sub-courses which are 6 weeks long each and are designed to show you, to support you, but most importantly to challenge you to be a UI Architect!
But… unlike most companies you train with we are very proud to tell you that we don’t just let our students rush in and learn what they want.
No, what we do at Logic Room is to start with what they NEED.
And we know as experts in the field of UI architecture, that our students need to learn the thing that is the highest priority FIRST, you already know what I’m about to say.
That’s right, you need to learn testing...
In the first 1-6 weeks we learn to make testing a UI app so fast, you will never want to ship another SPA without doing it!
In this first week we explore what you ‘think’ software architecture is about and what it is ‘really’ about…
We learn why testing is so slow because you do not have a go-to ruleset to help you lay out your files and data structures in a way that is consistent and repeatable, no matter how large your components become.
You can stop relying on complicated frameworks like Redux and instead learn the rules that stop your code and tests getting TANGLED.
Then we learn how to map UI architecture to your BRAIN and not React/Angular or Vue meaning you can process it faster.
We know the grisly mess that asynchronous programming causes!
If we aren’t deep in spaghetti call-backs then we are trying to swat a promise!
Instead, we learn to manually create and then leverage the observer pattern to gain fine grain control of our app state and therefore get TOTAL control over the Single Page App, and that means your TESTS become easy to READ and WRITE.
In training slide...
Now you have the requisite architecture knowledge, it’s time to write your first simple test.
But unless you have a repeatable pattern for making your test call your production code in EXACTLY the same way as the PRODUCTION code does, your tests are WORTHLESS.
Luckily in this week we learn the control patterns to fully control our app that so that it will load data and track state. Then we leverage the power of ‘black box’ design and test doubles to setup a clean, and clear System Under Test (SUT).
How DO we test COMPLEX app events such as user actions, API responses and application transitions in a single test?
We take principles from the last module and learn how to create consistent test code. This can then layer all of our app events in successive steps which we control without our tests becoming fragmented.
In this lesson we will learn how to build our complex tests meaning no matter the requirement that the suits from the business hand you, you can test it like a BOSS!
In training slide...
Testing at scale becomes slow when you cannot easily VISUALISE multiple paths through your features.
In this module we will learn how you can leverage patterns to build re-usable blocks of setup code in your test suite. It will give you confidence that your production apps are being tested like a real production app, WITHOUT coupling to the framework.
Wave bye-bye to duplicate code and lost ideas, and say hello to tests getting FASTER to write the more you have NOT SLOWER.
Ever wondered how you can do end-to-end testing in completely different parts of your UI without using end-2-end frameworks like Cypress, Selenium or Protractor?
Probably not, because you didn’t even think it was possible…right?
In this final module you will learn how to test ACROSS your UI that has multiple components, states and views.
Then you will find out how to make your tests work without using end-2-end tests, horrible snapshots OR confusing UI mocks – in fact to do this testing you won’t even need to use React or Angular – how cool is that?
This final module is the mastery to the first part of the training and you WILL walk away with your mind BLOWN.
The final technique you learn here will transform you from an engineer that says you DO TESTING to a UI Architect that says you LOVE TESTING!
In training slide...
In weeks 7-12 of the course we further advance your knowledge and show you the architectural rules and software design theory that will let you scale up your UI app to any size.
Do you find yourself spending too much time wrestling with React props? Got way too many complex objects in Redux? or perhaps you end up always fighting with Angular directives?
You could have... a presentation problem!
Left unchecked a UI app subtly buries too much information in the markup of your chosen UI framework. This week is going to blow-the-lid off this simple rule; good architecture starts with good presentation.
In this module we learn the fundamental difference between hierarchical data models and flat models, and how we can detect and fix bad views through the power of better presentation architecture.
In this module we will;
Let's face it, with all the hot air about software architecture why does nobody ever give us the ONE rule which makes all the difference?
In this module you will learn what that ONE most important rule in a UI app is! By discovering how an engineer cannot ‘see’ architecture unless they can 'control' it!
We do this by taking what we learned in the last module and creating 'breathing space' in our architecture. Then we can centralise a conceptual model which is designed to let us ‘think’. Trust me, if there is one thing you want to get better at when you are building architecture it's THINK, so...
In this module we will;
In training slide...
We do NOT want our UI apps to behave unpredictably and start throwing out data in odd situations or at the wrong time. Because apart from being stressful it also makes testing near on... __impossible__!
We will learn to leverage the paradigm of functional reactive architecture to cleanly solve both timing AND encapsulation issues properly. We are going to show you how to force a 'one-way' data flow on your app but without using a sea of complex tools. We will demonstrate to you the simplest way using the lightweight MOBX framework (but you can use any other FRP framework once you learn the rules).
So, in this module we go deep on the following;
If you have been shipping UI apps for more than a few years you will have seen the dizzying array of ways that module dependency loading works. Dependency loading is critical to a UI app, but the normal module loading tools do not give us the flexibility we need to SCALE because we are not in 'control' of the lifecycle.
We need control because often our dependencies are hard to test and hard to extend. For this reason we must have a way to centralise and dynamically load some of them. This will enable more flexible and testable code.
Learning all the subtle differences between the sub-topics of Dependency Inversion, Dependency Injection and Inversion of Control will enable you to confidently apply dependency management in your UI apps.
So, this module takes you deep into;
In training slide...
Do you dream of being able to create a multi-level, location aware, and configurable navigation menu and sub-menu-system, driven by simple JSON that works on both desktop AND mobile screens WITHOUT having to duplicate HTML?
Pssst, only JOKING 😃
That's exactly the sort of power I want in my UI apps!
If THIS is the sort of power you also crave, then don't fear this module... ABSTRACTIONS is what you need!
Everything you have learned so far has been helping you connect up the major architectural concepts in your UI app confidently. But you are going to need to manage some 'cross-cutting' concerns too. For example there are common features that almost every UI app needs; such as routing, navigation and 3rd party controls.
At best engineers tightly couple these concerns to the wrong places using the wrong interfaces. At worst they don't even have a design which defines them in the first place! They just bury these subtle but HIGHLY important abstractions in all the other parts of their app, like in-the-markup, noooo....
So, in this module we teach you how to interface your highly scalable UI architecture to all the cross cutting concerns. We do this by ABSTRACTING them into clear and unambiguous patterns that... WORK. We are going to tear apart your very real integration concerns that you WILL encounter in the wild, we cover;
By this point in the course you have now learned all of the foundation and critical knowledge you are going to need to confidently tackle and architect complex UI apps!
But your work isn't done until you have completed a 'final project' where you will holistically cement the knowledge you have learned so far! We have designed this final project to give you exposure to all the interlocking concepts you need.
In this module we will complete the 'Books and Authors' sample app by going through 4 stages together and building it one stage at a time.
Are you tired of working in chaotic teams, with 0 standards in UI architecture, a million egotistical engineers who can't agree on anything and a constantly changing approach to building apps that never-actually-work?
Yes, I feel your PAIN! In fact, I used to be FORCED to work in teams like that all the time. I'll be honest I HATED it because I had no choice.
But in week 13 none of us NEED suffer ANY longer.
At Logic Room we fulfil on our promises. We promised you at the start of your training that we would show you ‘exactly’ how to architect and test UI apps at scale.
But there is little point in giving you knowledge without giving you the opportunity to flex your new found skills in UI architecture!
So to prove our point in week 13 (Bonus Week) we offer to introduce you to teams that need engineers that are ready to go, and have been drilled in our breakthrough techniques.
So, our professional guild (by successful application only) will allow you to find teams that need to work with engineers who know, will use and love the techniques that Logic Room teaches!
There is a formal application process which is designed to figure out the right teams we can introduce you to. So what are you waiting for? Join up now!
Anyone who has ever trained with me will tell you I always say to people that I’m different to most trainers because I do not claim to be a ‘Guru’.
What I do claim is that I teach simple ways of doing complex work that are BATTLE tested on real projects that my company does commercially.
Yes, that’s right.
Myself and my team use these techniques that I teach on actual live projects for companies that we consult with.
This means that you are not gaining information which is based on subjective opinion but on the hard-learned lessons of commercial reality and real case-studies.
This means our training is simpler because we don’t have time to teach our clients pointless theory when they have actual deadlines to hit.
This means you get results first not theory.
Learn each low-level code structure rule from our training in simple exercises with a real persistent API. You combine these rules in the final project giving you the conclusive skills you need to begin scaling and testing your production apps infinitely!
We speak to 3 engineers about the course and how it has helped them create better UI testing and architecture.
When you enrol today you are going to get some extra bonuses that are not available outside this course.
Want to implement the code from this course in all the UI frameworks and tools?
No problem; in this first bonus we give you clear examples.
You will get code examples so you can begin using your new skills in legacy apps, more importantly you will have some blue-prints so you can begin helping your team use the same techniques we do in the course.
Only an architect should decide how to manage state?
Wrong, you should and CAN.
In this bonus we learn the theory of state and why you don’t need to be an Architect to make good decisions.
You just need to understand the theory of state in asynchronous apps.
Want to begin using observable frameworks with the techniques from this course?
In this code-dojo you get access to a 25 page e-book on the mystery of MOBX and how it can be used in a testing process to make everything MUCH EASIER.
The next bonus on the conveyer belt is 1 years access to our exclusive UI Architect community.
This will let you discuss ideas about the approaches you are learning, meet other people and be part of something special!
Let’s face it - learning is boring when you don’t have other people to work with.
So, at this point, you may be starting to wonder if a SYSTEM that can deliver all of this is going to be expensive?
And who can blame you?
That kind of power should be, right?
And even though I could easily charge several thousand pounds for this training and it would be totally worth it...
I’m not actually going to do that.
Right now, you can get onto the entire “12-Week UI Architecture Academy” programme along with all of the exercises, coaching and community, for just a one-time, single, secure payment of only £699.
That’s right, 12 weeks of training and coaching for £699 plus bonuses worth £425 (included for FREE).
That’s over £1124 of value!
At this point you might be worried that when you join the course - it won’t be as good as you want it to be.
And that’s completely ok - I have realised things weren't for me after committing to things in the past!
So, to make sure that you absolutely KNOW I have your back - I am going to let you TRY the training and not RISK A PENNY!
And if at any time in the first 30 days, you find that it wasn’t worth the £699... or you didn’t get the results you expected, just let me know, and I’ll IMMEDIATELY give you a refund.
So... if you join the course and do the first two weeks and then think… you know what Pete it doesn’t work for me…
You just email me, and I’ll give you your money back straight away!
So, the real question is... is it worth gambling a few minutes of your time to check this out?
Even if it only does HALF of what I've claimed today, it will pay for itself as soon as you start to see real results faster than you ever dreamed possible.
So, if you’re ready, just go ahead... click the "Buy Now" button below and take advantage of this very special offer.
Have you ever heard of the Pareto principle? The Pareto principle recognises that in nature we often see 20% of the effort yields 80% of the result!
Whilst this course does not NEED you to be a React engineer having some knowledge of it will help you work faster through the exercises.
That’s why we are going to give you our lightning fast, easy to digest, React quick start course with included quick start code samples.
We have created the React 80/20 guide to get you going fast by learning the most foundational things you are going to need to build React apps.
No matter if you are a Vue, Angular or just a Vanilla JS engineer this crash course in React gives you the foundational concepts you need to know about React!
Added to the other 4x bonuses this gives you a total value of £472 in bonuses alone!
The course is remote, you use our platform to get lessons and material and then we have group coaching calls.
Yes, you can. We think it's best if you keep up with the schedule (the correct content is fed to you each week) but if you fall behind don't worry, you just do it when you are ready in 12 weeks or even 12 months ;-). The group coaching is currently every 2 weeks and you get 6 sessions. If you miss a session you drop into the next one!
Just a modern browser and a laptop – nothing more. It’s all 100% cloud based, you even get your own online test DB. You are able to reset it too.
YES! We use React and Mobx but you will learn how to port the specific framework code we write over to your chosen framework (React, Angular, Vue, Redux etc).
Currently and because this is a new course we are giving lifetime access to the course material (videos and code samples).
So you typically need to know less than you do with other courses.
Version 8 (ES 2017), Jest and React to demonstrate the techniques and give you exercises.
The techniques are 'framework agnostic' so you can begin using them in any app using any framework (Angular, Vue, Backbone etc).
We are a consultancy that teaches programmers REAL skills not just dry theory. We serve engineers first, and businesses second.
As soon as you pay you get access to the first week/module.
Group coaching starts after Week 3, the calls are every week at 7pm GMT. we mail you to let you know when they are.
If you miss one - no problem just drop in the week after!
We use Webex and group call. You can post questions before the group call if they are complex so we can try and get an answer for you.
What you put in - you get out!
Some people will grasp the concepts quicker some slower (and there is absolutely NOTHING wrong with being a slow learner).
That said you will need AT LEAST a few hours every week to cover material, do the coaching calls, catch up on missed calls and then do our exercises.
See see the checkout page!