Tech
Xamarin Forms has now been superseded with .NET MAUI. In this blog post, I'm looking at the process of upgrading an existing Xamarin Forms project to MAUI. How much effort is needed and what will still work or needs to be updated.
What is the best way to test the repository layer of a spring boot application? Or should you test it at all? What are Testcontainers and how to use them? This article addresses them all with examples, so you can make a better decision when you are faced with a similar challenge in future.
Newcomer desktop-web framework Tauri has quickly attracted the interest of developers looking to build cross-platform desktop applications using web technologies. Promises of smaller and faster applications certainly appeal to those using Electron. In this post, I’ll take a look at what’s new in this space, what distinguishes them, and why WebView2 doesn’t solve everything.
Late last year I attended DevTernity, an all-remote generalist software development conference. In this post I'll cover off some points of interest from some of the talks I chose to attend, and reflect on the remote conference experience.
Here are five books that influenced my coding style and working practices early in my career. A top list of anything is deeply personal, so I’ve tried to select books I found both inspirational and informative, with an equal focus on technical and non-technical skills.
A Vim clutch is typically a repurposed keyboard/guitar pedal that enters insert mode when you press down on it and leaves it when you release it. This can and has been accomplished in a great many weird and wonderful ways. This post adds yet another to that list.
A brief overview of the creation, workings and application of the markup language Markdown
EDGY is a new graphical design language for visualising enterprises. This new open source design language shows great promise as a tool to bridge across siloed teams. This post explores the preview edition at a high level.
There are a growing number of voices heralding Web3 as the future of the internet, and this technology (concept?) is receiving considerable coverage at conferences, in the technology press, and internet forums. I decided it was time to put Web3 to the test and see how it fares against the contemporary approach to building apps - the public cloud. Unfortunately I found Web3 to be very lacking.
Learn about what a data platform is and how it can translate enormous amounts of unstructured data into meaningful reports on your business operations.
A whistle-stop tour through some of the LGBTQ+ computer science pioneers ,the technology they created, and the impact they have had on modern computing.
WebAssembly has gone through quite a transformation this last year, while the wasm language landscape is slowly shifting, the more notable change is in what people are using WebAssembly for. The use of wasm for serverless, containerisation and as a plug-in technology has leapt considerably, with WebAssembly System Interface (WASI) becoming ever more important.
Ever wondered how to tell how strong your pasword is? This blog post explores this question using the popular Wordle puzzle game for context.
An introduction to the tree data structure. Trees are often shrouded in mystery and stoke fear in the hearts of software engineers. Today we look at the different types, how they work and most of all, how do you implement one!
WebAssembly is really starting to shine is as a standalone runtime environment. In this blog post I explore the Wasmtime WebAssembly runtime, and build a WebAssembly-powered serverless platform in just 70 lines of code.
·
Video
As far back as 600BC there is evidence of people encrypting messages to send secrets. Originally it was mainly used to conceal tactics for battle, but now encryption is used frequently in our daily life. In this talk, I describe how methods of encryption have changed through time.
·
Video
Recently, WebAssembly has been a hot topic in tech and developer forums. In this talk, I discuss one use-case: the creation of a UI that runs in browsers, which is powered by WebAssembly (compiled from Rust).
·
Video
We’ve all played a game with Box2D physics (e.g. Angry Birds). Google forked Box2D to add fluid simulation, but diverged irretrievably in the process. In this talk, I ask whether we can salvage Google’s contributions and bring both these C++ projects to the modern web using WebAssembly and TypeScript?
It is quite common for blogs, or news / content distribution websites, to organise their content around categories of tags. However, this approach is time-consuming, and from measuring behaviours, it doesn't seem to do much to encourage browsing. In this blog post I use the new OpenAI embedding API to create highly targeted article recommendations, resulting in a four-fold (x4) increase in engagement.
A very simple introduction on how to begin pondering about the environmental impact that software can have on the planet. Nothing too technical more just an introduction.
·
Video
In this talk, I share the key things AI can learn from Neuroscience, and why these two disciplines need each other in order to progress successfully.
Everyone loves CSS! So I built a calculator where the CSS handles the logic without the help of javascript. In this blog post, I will discuss how I achieved this and maybe make a case for my sanity for making it.
There is a lot of information available to us, but we often just read and forget. Using a digital Zettelkasten is an effective way to store and make use of the things you learn.
Apache JMeter is a very popular performance testing tool which I used recently for load testing a server. In this post I will take a brief look at how to use it to perform a basic HTTP load test on a server.
.jpg)
You can tell powerful stories with data, but so often we are faced with raw data (albeit beautifully presented), and are left to create our own narratives. My previous attempts at turning data into stories have been time consuming and underwhelming. In this post I demonstrate how GPT-3, a new and advanced language model, can construct engaging and unique stories from user-specific data, with relative ease.
The Disruptor was developed by LMAX to improve Java inter-thread communication for extreme low latency applications. In this post I will outline what is the Disruptor and see what we can learn from the framework for building future applications.
Have you ever wanted to learn Rust or just simply know why everyone is so hyped about it? Well, I’ve put together a pile of links to interesting resources to get you started!
·
Video
I talk about GPT3, one of the massive and very impressive AI models to come out of OpenAI. I quickly cover off the basics of how it works and where its creativity comes from, before accidentally delving into existentialism.
·
Video
In this talk, I summarise the first steps in creating a Seasonal Cocktail Playlist by outlining how to apply Data Science skills when cleaning and labelling a cocktail data set.
·
Video
While we are all working remotely, code reviews should be an opportunity to grow as a team, but too often they can become something we fear, hate and avoid. This talks suggests an approach to remove conflict while strengthening the team.
·
Video
Sometimes it’s important to show progress to people who don’t care about APIs and there is no time to put together an elaborate UI.
In a previous blog post, Colin focused on rendering massive numbers of points using D3. In this post I'll consider how you can efficiently load that data using Apache Arrow.
When coming to TypeScript from OOP languages it can be very easy to fall into the trap of using types the same way you are used to. But this is missing a lot of power of TypeScript. This article looks at how you can extend your TypeScript use to not only represent types, but also express the intent and document your code better.
The OpenAI Codex JavaScript Sandbox and the API which backs it, have (rightly!) generated a lot of interest and comment in the development community. When faced with something so different to what we expect, it's easy to assume it's all magic. In this post I'll peel back some of the layers and try to describe what's going on.
Timezones, and daylight saving - the practice of moving clocks forward by one hour once a year - are a pain. They make it hard to schedule international meetings, plan travel, or may simply cause you to be an hour late for work once a year. For a developer, they are even worse! This blog post takes a visual journey through the last 120 years of timezones, daylight saving and the ever changing world time.
Always wanted to write a custom linting rule for your JavaScript project, but never been sure where to start? This guide will introduce the key concepts you need to give it a go!
...or what I should have known before I jumped in and started playing around. In this post I cover few shot learning and fine-tuning.
...or what I should have known before I jumped in and started playing around. In this post I cover logprobs and the "creativity" controls.
...or what I should have known before I jumped in and started playing around. In this post I cover the basics of tokens, the model and prompt design.
·
Video
Last month GitHub released Copilot, an AI powered tool that provides surprising accurate suggestions ranging from a few lines of code to entire functions. Copilot uses a vast and powerful AI model that is trained on billions of lines of open source code from GitHub. This, combined with the context provided by your code and comments, allows it to provide amazingly accurate suggestions. This is no simple autocomplete, this is pair programming with a robot!
TypeScript can enhance the experience of developing React components. However to fully represent the types of some dynamic components, we need to harness the power of union types. This article examines an example where union types improves our component typing.
I've been lucky enough to be granted access to the preview of Copilot, GitHub's new 'AI pair programmer' that is causing quite a stir. This blog post shares my initial thoughts and experiences with this tool. In brief, I'm stunned by its capabilities. It has genuinely made me say 'wow' out loud a few times in the past few hours, not something you expect from your developer tooling.
When using TypeScript for many developers it is natural to compare to Object Oriented languages. However TypeScript is different. This article looks at one tool that does not exist in Object Oriented languages: Union Types, and how you can use it to improve your TypeScript.
When first using TypeScript you get presented with a choice, do I represent that with an interface or a type alias? In this article I explain the differences and why and when you should choose one over the other.
This blog post shares the results of the first State of WebAssembly Survey, with results from 250 respondents surveyed in June 2021. We find that Rust is the most frequently used and most desired WebAssembly language and many other interesting results
RTK Query is the latest addition to the Redux family, intended to make loading data from a server as easy as possible. In this post, we'll look at why I'm so excited for it, and answer the question "but why does redux care about data fetching?"
·
Video
In this panel discussion, Ash Smith (GDS), Cheryl Stevens (DWP) and Mike Crockart (The Scottish Government) discuss their approaches to identity assurance, including opportunities to improve the user experience and potential obstacles to overcome along the way.
.JPG)
·
Video
In this talk, I delve further into the proposed transition from Open Banking to Open Finance, discussing some of the possible opportunities and challenges on the journey.
In advance of the event on Profit with Purpose that I'm participating in during Digital Leaders Week, I reflect (briefly) here on my experiences in Government, my thoughts on some of the challenges that still lie ahead, and why I’m excited to be the new ‘gaffer’ at Scott Logic.
Follow-up article to "Why Java Developers Should Learn C++". If you are interested in picking up C++, or enjoyed my previous post, this can help you get started.
A step by step guide through the process of building my first bespoke animation with SwiftUI. Touching on technical aspects specific to SwiftUI and more general concepts relating to animation.
·
Video
Data Mesh: What's different about it, what it means to DWP, and how you might approach it yourselves
Data Mesh is an emerging architectural paradigm for big data that addresses the challenges inherent in the data lake and data warehouse approaches. In this talk, I define what it is, and Charlie Boundy, DWP Deputy Director and Head of Data Science, brings it to life through DWP's technology and data vision.
An exploration of how to setup up a basic multi-platform SwiftUI project, including platform specific files, common files and conditionally compiled platform code.
·
Video
With APIs, Open Standards and modern tooling, the vision of GaaP is more readily achievable than ever before, but it requires a different understanding of the role of government — from master and commander to convener and enabler. In this talk, I bring to life why I believe APIs are key to establishing digital foundations that will enable us to better serve citizens' personalised needs at scale.
·
Video
In this session, I consider how legacy dictates our view of APIs and explores how, with a fresh perspective, we can maintain focus on recognising the full value of APIs in achieving control of legacy.
·
Video
In this talk, I explore a little of the history of the term API and covers what he considers to be the three most current use cases. I talk about REST and GraphQL with a look at the evolving standards in the 'API over the internet' space. I also look at how the popularity of Event Sourcing has led to a rise in the number of Asynchronous APIs and how standards are emerging in this area too. Finally, I round off with my predictions for the future of Web APIs and signposts some of the technology which is shaping that future.
·
Video
An API Strategy is vital for focusing resources, aligning stakeholders and ensuring that APIs deliver a good return on investment. In this session, I provide my perspective here on the major elements of an API strategy and discusses some of the areas to consider when designing one.
Micro-frontends is a relatively new architectural style for building web-based applications, which as the name suggests, is an extension of the popular microservices pattern. In this blog post I argue that this is a pattern you might not need!
Flutter is a cross-platform mobile UI framework which allows you to develop an app for Android and iOS with one codebase. But is it any good?
·
Video
Our panel of experts — Jacqui Leggetter (Head of Integration (Deputy Director) at DWP), Kevin Dearing (Head of API Ecosystems at NatWest Group) and Benny Boye Johansen (Head of OpenAPI at Saxo Bank) — share success stories, lessons learnt and practical advice based on their experiences of using APIs as a strategic enabler and value generator.
Svelte is one of the most exciting parts of front-end development today. But what is it, exactly? In this post, we take a look at the philosophy behind Svelte and see how it affects everything Svelte does.
JavaScript provides a Promise abstraction that can be used to express 'give me the result later'. What happens if you ask for the result twice?
It's the end of the #AdventofCode for 2020. I take a look back over the final 6 puzzles and sees how much was possible in BaseA Alteryx. How close did I get to solving all 50 stars in BaseA!
19 days in, the end of the third week of the #AdventofCode. The challenges have got harder and some have taken a little more than just BaseA Alteryx functionality but am still going strong. Here's my look back at solving the puzzles over the last 7 days.
·
Video
A talk, from the Open Source Strategy Forums, where I compared some of the challenges facing open source (complexity, fragility, sustainability) to those which triggered the financial crisis of 2008.
As week 2 comes to a close on the Advent of Code, a look back at how the puzzles have been solved using BaseA by the community and me. The challenge has definitely increased this week!
Everyone hates bugs. Unfortunately, as codebases grow, it's easy for bugs to spread out of control. Fortunately, they can be brought back under control using psychology and a mathematical model from the 1950s.
It's the end of week one in the Advent of Code and, as has become a little bit of an annual tradition, I and other's from the Alteryx community are trying to solve with the base tools. In this post, I look back over the first 5 puzzles and how I (and others) have solved them.
OpenFin enables the use modern web technologies in place of older legacy systems. In this post we investigate the 3 primary communication techniques made available when using OpenFin to build the next generation of applications for the financial desktop.
In this post I'll try to lay out some requirements for 'good' code, talk about how we might define 'easy' code and how this correlates with a definition of 'good' code.
The WebAssembly build of FFmpeg allows you to run this powerful video processing tool directly within the browser. In this blog post I explore FFmpeg.wasm and create a simple client-side transcoder that streams data into a video element, with a bit of RxJS thrown in for good measure.
Narration.studio is my latest project: a web app for automatically editing voiceovers. In this first part, I introduce the project and the motivations behind it.
d3-zoom is incredibly robust, powerful and flexible. However, its flexibility means it can be quite complex to configure and use correctly. This post covers one way of wrapping it up, reducing its flexibility but vastly simplifying its use for my use-case.
Van Halen famously requested M&M's with no brown sweets as part of their 1982 world tour rider. What, if anything, is there to learn from this ridiculous demand, and can it help improve our software development processes?
This blog post looks at how CSS flexbox item sizing works, how it is used to create responsive layouts, and how it can be used to display interactive charts without using any Javascript.
Over the past few months I've had an ergonomic keyboard obsession. It started out simple, just wanting to improve my typing experience. It ended with me writing a driver. This is my story - now available as an audiobook!
Learn Rust, the tech industry's most loved programming language by building Snake, the simple but addictive game found preloaded on old Nokia mobile phones.
Redux is a great state management library, but its types are too broad. Using the builder pattern, we can generate exact types and ensure type-safety throughout an app.
The world is racing for quantum supremacy, to solve problems once thought impossible on any reasonable timescale. In this post, I explain the fundamental principles that allow this to be possible.
This is part two of a series introducing Vue to developers who are new to the ecosystem and evaluating whether to include it in their next project. In this post we will look at Vue components but check out part one if you are looking for an initial overview.
This blog post is written for developers who have not used the Vue ecosystem before and want to decide whether to use it in a project or not. To help with this decision, this blog post will give a brief overview of the technology and ecosystem.
TypeScript's type system is amazing, but it can't do everything. In this post, I demonstrate how the builder pattern takes my types to the next level. We walk through an example in detail, so you can start using builders too.
·
Video
There's a standard approach to migrating legacy applications into desktop containers: the desktop equivalent of the strangler pattern – but this has its drawbacks. Is there another way? In this webinar, I shed light on an alternative that addresses these drawbacks and opens up new opportunities for old tech. And I explain what on earth rollercoasters have to do with it.
Published in 2007, Amazon's Dynamo paper changed the distributed database world. As well as powering AWS S3, it also inspired many well known open-source NoSQL technologies such as Apache Cassandra, LinkedIn's Voldemort and Basho's Riak. This post intends to present the paper and its concepts in a digestable way.
In this blog post I'll be demonstrating how quickly it's possible to setup, integrate and deploy a React application using the right tools.
Writing emulators that bring old computer hardware back to life is a popular hobby, and one that I have been enjoying recently through my own goal of writing an Atari 2600 emulator. However, writing a CPU emulator can get a little repetitive and tedious, so I thought I'd explore a different approach - generating the CPU emulation code from a specification rather than manually translating it. This blog post shares the fruitful results.
With so many organisations claiming to do microservices, it’s time to re-examine. Let's explore the principles of microservices and how the mindset transcends specific technology choices of the moment. It's more about people and change than it is about technology.
·
Video
This technical webinar sets out the steps involved in migrating a legacy application into the Finsemble desktop container, and introduces some of Finsemble's main features.
·
Video
This technical webinar sets out the steps involved in migrating a legacy application into the Glue42 desktop container, and introduces some of Glue42's main features.
I've been using Svelte for about 6 months now, and the worst bit has always been the lack of TypeScript support - but it's finally here! This post shows you how to get started using my two favourite web technologies together.
We explore how to use Spring Profiles as a handy way to select the configuration at runtime by wiring in different beans, as well as looking at how to autowire different beans in for integration tests.
·
Video
This technical webinar sets out the steps involved in migrating a legacy application into the OpenFin desktop container, and introduces some of OpenFin's main features.
The function console.log is a JS developer's best friend. In this post I explore the console API in greater detail to help you in your next big project, or help you mess around.
Accessibility is essential to provide a high-quality experience for all of your users. However, it can be easy for failures to slip into our applications. In this post, we'll look at the six most common accessibility problems and discuss why they matter and how they can be fixed.
·
Video
This webinar explores the potential and realities of an emerging vision for a more integrated desktop application ecosystem, as facilitated by various open-source and vendor products.
·
Video
WebAssembly is a brand new W3C standard for a secure and load-time optimised, stack-based virtual machine that is a compilation target for a broad range of languages. That's clear isn't it?! This talk will provide a very gentle introduction to WebAssembly, with practical examples. By the end of the talk you'll have a much better understanding of this exciting new technology.
In this post, we work through building up a cubic spline from first principles first in Python, and then converting the Python code into an Alteryx macro
In this post, we look at creating a brute-force search approach to solve Matt Parker's Coin Puzzle using some binary manipulation within Alteryx
One of the most common complaints when someone starts learning React Redux is that it's too magic. In this post, we'll be pulling back the curtain on React Redux to discover how it really works.
This blog post introduces the WebGL components which we recently added to D3FC, this suite of components make it easy to render charts with very large numbers of datapoints using D3. Throughout this post I'll describe the creation of the following visualisation, which displays 1 million books from the Hathi Trust library
Async iterators are a great language feature that make working with asynchronous streams of data a joy to use. We'll take a look at consuming an async iterator running in a Web Worker from the main thread and see how we can use a library called Comlink to abstract away the fact it's running in a different execution context.
The second in a series of posts exploring the things that Spring Boot does when it magically Autowires application dependencies. Is it really a kind of magic, or is there no such thing?
WebGL presents you with a blank canvas (literally!) and leaves you with what feels like an overwhelming set of decisions to make before you can render your idea on screen. This post introduces a quick reference guide to picking the right draw call for those trying to decipher the difference between drawArrays, drawElements and their oddly-ANGLE'd instanced equivalents.
The date is March 31st of the year 2020, and things have gone wrong. What follows is the account of a software developer confined to his home in Bristol as the people of the world come together apart, in defiance of this simultaneously macro-and-micro-scopic attack on our very species.
Some might say I pushed the Micro:Bit too far. This post is not for those people. If your Micro:Bit is also struggling, this post will show you how to optimise your code and push it further
Rendering charts can be a very intensive operation for the browser, especially multiple charting widgets in the context of a wider application. OffscreenCanvas is growing in browser support and allows canvas rendering to be delegated to a WebWorker. This post looks at what performance improvements we can realistically expect and some gotchas that can crop up along the way.
Frontend web technologies are increasingly being used beyond traditional web applications. Could the next frontier be multi-window web apps that run in both the browser and on the desktop?
Ray tracing is the process of simulating light rays to render a 3D scene. It seems really complicated at first, but it's actually quite simple. After reading this post, you could easily implement one yourself!
I recently got the chance to play around with a BBC Micro:Bit - an educational toy aimed at helping kids learn to program. It's designed to do a lot of things, but 3D rendering isn't one of them.
A look at the design principals behind the Aeron messaging system and the consequences on its suitability for Scott Logic's purposes.
A series of posts exploring the things that Spring Boot does when it magically Autowires application dependencies. Is it really a kind of magic, or is there no such thing?
Practicing Continuous Integration & Deployment, we can get new features to users faster and tighten our feedback loops. In this introduction to CI/CD, I introduce and explain an example GitHub Actions workflow which builds your front-end and deploys it with GitHub Pages
After hearing about Svelte, a performance-first web framework, I tried it out in a web-based Minesweeper solver. SHOCKINGLY, it didn't automatically make my code fast - that took a process of iterative optimisation
For the past 3 months, I have been a bit obsessed with Minesweeper. It has plagued my honeymoon, stolen my free time, and been the subject of two tech talks. That's a good thing.
In this post I explore the Bindable SwiftUI Redux package I created, and explain the motivations behind using Redux for state management in SwiftUI, and the challenges faced in integrating the two frameworks.
This post discusses one way to add Playwright to a create-react-app generated app, and shows how easy it is to use for cross-browser UI automation.
Interface Segregation is an important part of writing clean and maintainable code. In most languages, it requires constant maintenance and naturally degrades over time. In TypeScript, we can just Pick the good bits.
In this post I take a closer look at how SwiftUI uses declarative syntax to construct view hierarchies, and how it transmits state updates to the UI.
This post looks at adding Puppeteer to a create-react-app generated app, and shows how easy it is to get Puppeteer up and running.
We - Alex and James - are graduate developers and our first project introduced us to Infrastructure as Code (IaC) and serverless architecture. This post is a collation of useful resources and thoughts gathered on our journey to help you learn about AWS, Terraform and Serverless - it's the guide we wish we had.
In this post we will be investigating how we can improve the performance of a chart created using D3FC and WebGL by using a lower level API from the d3fc-webgl package.
SAT solvers are surprisingly fast and probably under-used. Could one help us improve sprint planning meetings? Maybe, but first you'll have to change the way you think about user stories.
Rebasing is a technique available in Git, often shrouded in mystery or steered away from, this post explains what it is and how it can be used
Improv is one of my favourite pastimes. In this post I explore some of the most fundamental rules of Improv and what they can teach about writing good code.
In this post we will be looking at creating a chart using D3FC and the new WebGL functionality. With the performance boost that WebGL provides we will see how we can render a large data set of around 54,000 points in a single pass.
The more advanced, time saving and helpful techniques of any source control tool require an understanding of the fundamental concepts of any source control, here we cover the most important ones
In this post I look at how SwiftUI manages state with Combine, and how it compares to using React with Redux. SwiftUI is Apple's new declarative UI framework for developing UI natively, while React is a declarative UI framework for the web.
DTOs help translate data between server and client. By going back to first principles, how can we utilise static type-checking and integration with modern IDEs to write a better DTO?
An Augmented Reality Sudoku solver using the WebAssembly build of OpenCV (a C++ computer vision library), Tensorflow (a machine learning library) and solver written in Rust. It neatly demonstrates how WebAssembly allows you to write performance-critical web-based applications in a wide range of languages.
Delivering software fast and with as few bugs as possible is not an easy thing to do. Developers often blame the lack focus on technical debt for a buggy solution, while testers point to well... lack of testing. In this blog post I will talk about the idea of "sustainability" in software delivery and how thinking and using it may make your project more successful.
I've been authoring the WebAssembly Weekly newsletter for just over two years now. As we near the end of 2019 I want to take the opportunity to share some of my favourite articles from the year.
We're told that we need to commit early and often. But what does this mean...? What is the right frequency? When should branches be used? When do they work well, and when should they be avoided?
This is a post about doing performance right when building large and complex web applications. Much advice is available about optimising for every last ounce of performance on the web, but that won't help much if we don't already have 'good' to begin with.
Regular expressions are very powerful, but something that many developers are wary of using—they have a reputation of being difficult to understand. If you appreciate their underlying principles, you can understand them better, and if your code takes advantage of this, you may be able to refactor them into a more readable form.
This is the first of a series of blog posts exploring SwiftUI, the new UI framework for native Apple development. This post will focus on my initial impressions, having gone through the first part of Apple's SwiftUI tutorials.
We are taught how to write good code, but we're not taught how to use source control properly. Why is the history of our code any less important than the code itself?
Prettier, or code formatting in general can polarise developers - everyone has an opinion on braces. There are changes we can make and tricks we can apply to streamline all of this. Or: How I Learnt to Stop Worrying and Love Automated Code Formatting
An introduction to ArchUnit; an open-source, extensible Java unit testing library for enforcing your architectural and coding rules.
The switch statement in Swift is a powerful and expressive way of performing flow control. It pairs very nicely with a few other language features: enumerations, extensions and type inference.
Protecting your data by generating visual reports for your users in an optimal way without exposing the raw data using serverside generation.
An overview of the methods we used to create and deliver digests (emails containing information on a topic that users are subscribed to) using Elasticsearch and serverless architecture on AWS.
Drawing and shading an area around a line is a useful feature for any charting library. In this post we will be exploring the approach we took to implementing this functionality for the D3FC library using WebGL.
WebAssembly, despite the name, is a universal runtime that is finding traction on a number of platforms beyond the web. In this blog post I explore just one example, the use of WebAssembly as a smart contract engine on the blockchain. This post looks at the creation of a simple meetup-style event with ticket allocation governed by a smart contract written in JavaScript.
Earlier this year React released hooks, shaking the codebase of developers all over the world and changing the way we write React web applications. Functional components with hooks have largely replaced class components and now Redux has followed.
The second part of a practical series on building Microservices with Spring Boot and Spring Cloud. In this post we expand on our previous online store project, scaling out while introducing the concept of client-side load-balancing using Netflix Ribbon and Feign. We also implement fault and latency tolerance with Netflix Hystrix.
Connecting points on a chart with a line is one of the most basic uses of a charting library. When drawing that line in WebGL, however, it's not as straightforward as you might think.
A very quick experiment into setting up a new development environment in GitHub and Visual Studio Online for creating Python-based AWS Lambdas
A practical series on building Microservices with Spring Boot and Spring Cloud. In this post we get started by building some services for an online shop and tie them together with 2 more services, backed by Netflix's Eureka and Zuul.
I am constantly amazed at how unfamiliar otherwise competent developers can be with numeric types. In a series of two blog posts I will explain what you need to know to understand the JVM's numeric types. This first installment covers the integer types.
In a React app, opening and sharing data with a new (non-modal) window might seem like a challenge, but it's possible - and I've provided a component to make it even simpler.
When first using WebGL, even rendering a simple shape can be a challenge. In this post, I take a look at the approach we've taken in D3FC to render shapes using the fragment shader.
Taking a look at Microsoft's new product .NET for Apache Spark by writing a C# app that writes Spark dataframes to a SQL database.
For the past few months I've been using Visual Studio Code Remotes, a powerful new feature that is available in Visual Studio code.
In this blog post we consider a practical example of how the D3 and X3DOM libraries can be used together to build dynamic 3D charts for the web.
An introduction to our recently released open-source React Hooks library, OpenFin React Hooks. Developed especially for OpenFin and its developer community.
SwiftUI is Apple's new UI framework for all its platforms - watchOS, tvOS, iOS and macOS. This post explores the significance of its release, comparing it to both to former native iOS development and competitor frameworks.
In this post we look at X3D and how it offers a simple declarative approach for including 3D visualisations in web pages in a way that is supported by major browsers.
Caching frontend application bundles isn't as effective when they're updated frequently. In this post, I'll explore the idea of using deltas to update already-cached bundles, and cover some approaches - including one that's feasible today using service workers.
Reactive programming is a powerful technique for handling data that changes over time, time-bound events, API requests and updating the UI. This post is a summary of how the reactive paradigm works in Android.
Swift combines the type and memory safety of a language like Java with the simplicity and ease of languages like JavaScript and Python. This article will explore some of the language features that, in my opinion, make Swift the most beautiful language to read and write.
Why Java Developers can gain from C++, what C++ can gain from Java Developers, and how the language has made itself more comfortable for you to make the transition.
Spring Boot applications have quickly become one of the most popular Java frameworks due to the speed and simplicity of creating production ready applications. Sometimes the world of Spring can be confusing - in this post I give an overview of some fundamentals of Spring, what Spring Boot is actually doing, and where to start if things go wrong.
When WebAssembly was released a couple of years ago it was an MVP (Minimal Viable Product), one significant feature that was missing from the MVP was threads. The WebAssembly threads proposal is now quite mature and available in both the tooling and Chrome. This blog post explores the internals of this feature, the new instruction set, and how it supports multi-threaded applications.
Scott Logic is proud to have been identified as one of 1000 Companies to Inspire Britain in 2019 by the London Stock Exchange Group (LSEG).
This article is for anyone interested in learning more about Amazon Web Services (AWS). It talks about training resources, getting practical experience and staying up-to-date.
As a front-end developer working on real-world applications, WebAssembly isn't something I can actually use, is it? Let's find out how easy it can be using AssemblyScript.
Styling in Android can be a difficult experience for developers not familiar with how the framework works. However, once you start to understand the "Android way" the development experience can be both logical and enjoyable (excepting a few Android quirks, but for the Android developer - c’est la vie).
React and Vue are two popular web application frameworks aimed to make developing user interfaces easier. This post summarises a few of the similarities and differences between them I found after using both.
Is WebGL faster than Canvas for drawing 2D shapes, and if so can we harness that speed to visualise very large data sets? I wanted to learn WebGL so I decided to investigate this question and learn at the same time.
The 'Performance' tab of Chromium (Google Chrome) DevTools isn't always enough for analysing complex multi-window Electron web-desktop applications. In this post, I'll introduce the related but lesser-known Tracing tool, and show how it can be used with Electron.
Have you ever wanted to write your own compiler? ... yes? ... of course you have! I've always wanted to have a go at writing a compiler, and with the recent release of WebAssembly, I had the perfect excuse to have a go.
The d3fc cartesian chart provides a simple way to compose the most commonly used type of chart, while keep its API simple. But would it be possible to keep that simplicity while making a chart component that is more flexible?
Recently we've been looking at enhancing the D3 axis component to implement a number of common features including more flexible label placement (e.g. positioning labels between ticks) and rotation / offset of labels to avoid collisions. This blog post demonstrates some of these features and how they were implemented.
Hooks are one of the most exciting features of React in recent times, allowing the developer to "hook" into React features without having to use class components. In this post, we take a dive into Hooks and learn how, when and why to use them.
Can Kotlin, the latest language to join the JVM, supersede its predecessor Java? Let's compare the two languages that are currently battling for supremacy in the world of Android.
·
Video
This talk, from London Node User Group, looked at some of the internals of WebAssembly, exploring how it works ‘under the hood’ with a demonstration of how you can create your own (simple) compiler that targets this runtime.
Persisting data can be easy with an ORM like EF Core. Let's take a look at how we can save our data without compromising our domain models.
A working example of how to create a new plugin for Perspective, using a ready made template to get started quickly, and open source mapping API from OpenLayers.
How we built a plugin for Perspective from JP Morgan, using d3fc to display a generic charting view that can show multiple chart types.
We usually need to consider data persistence when writing an application. In this first part we look at how to model your domain in preparation for use with Entity Framework.
A lot of developers start specialising in Javascript, and have an inherent fear of Java (I know I did!) In this blog post I look at a few tips to get over that initial fear and start coding in Java, from a Javascript background.
My personal reflections on the sessions that I attended at the 2019 Build IT Right conference. Continuous Delivery, embracing conflict and fighting entropy.
The WebHID API will allow web applications to use human input/output devices connected via Bluetooth or USB. This post takes an early look at where it fits in, the possibilities enables, and how to use it.
If I said the words "a tech conference for women" - what would you imagine? Would it be the attendees sitting in circles, holding hands and admiring each other's beads? Do you picture 'sisters' singing kumbaya and plotting the downfall of the patriarchy? Would you picture sessions such as "how to code for fluffy-wuffy knitting sites?" Would you wonder if it was full of hardcode coding and hacking sessions to get women further up the knowledge ladder? Some of the Scott Logic tech staff went to a technical conference for women. This is what it was like.
In this article, I share my take on the recent AWS Builders Day in Edinburgh. I delve into a couple of the talks i attended which were primarily focused around AWS AppSync, AWS Amplify and GraphQL.
This post addresses how to grant access to Firebase Test Lab without also granting access to your wider Google Cloud Platform services.
D3 and d3fc are powerful tools for creating charts in JavaScript. This post will look at one way to create a continuous colour range legend to annotate one of these charts.
Changes to code formatting tooling/policy can be painful to integrate with work-in-progress branches. Here's an approach to solving the situation quickly and easily using a single Git rebase command.
When first learning to develop in Swift, there were many cases in which I would become frustrated at some of its unique features. However, the more I learned about Swift, the more I realised these features weren't so crazy after all.
Riders of public transportation rely on real-time traffic information (RTI) systems to make informed decisions. But really how accurately are those systems? By systematically collecting and analysing the Open Data exposed, we can gain some insight into the question.
Where does one start when looking to write better code? And how do we maintain code quality and consistency when working in a team? These two questions drove me to create a language-agnostic guide to writing decent code.
·
Video
With open source projects, we often work with strangers, people we may never speak to, let alone meet. Creating a quality product, with such a disparate team can be quite a challenge. This talk takes a look at how tools and automation are a critical component when creating a successful open source project.
It's useful to be able to use components built using one framework, within different frameworks. In this post, I explore considerations and patterns, and finish off with an example using React and D3.
This article describes an experiment about building my own DOM render utilities. It is written incrementally following a sequence of commits, each of which brings in a new feature. The results are a tiny library, some learning along the way, and too many questions left unsolved !
Hi, I'm James. I recently worked on an Android project for Scott Logic and want to share with you some of my tips for starting out as an app developer. If you are a developer wanting to learn how to code Android apps then this article is for you.
We've updated StockFlux, our OpenFin demo app, to make use of the recently-released OpenFin Layouts APIs. This blog post takes a quick look at the features we've added, and the APIs used.