This year I’m attending the Linux Foundation Europe Summit, a sizable event bringing together 1,000s of people involved in open source. Day two was packed with surveys, statistics and the fragility of the node ecosystem..
This year I’m attending the Linux Foundation Europe Summit, a sizable event bringing together 1,000s of people involved in open source. I typically take extensive notes of the sessions I attend, so thought I’d share them here on our blog.
Discover how to streamline metrics collection in Jest test suites using a centralized 'metricsCollector' utility, simplifying test maintenance and enhancing data-driven testing practices.
In this blog post I will walk you through how to set up a Jest custom environment in order to dynamically skip tests after they have been queued.
JSON Web Tokens are a secure way of transmitting information between two parties. This article explores what they are, how they are made, the kinds of JWTs that are commonly used and their key benefits.
You think software has enough variables, right? Well there is another one that has become a big consideration when designing, developing and deploying software and its name is Sustainability. This area of consideration comes with its own terminology and with this blog post I hope to shed some light onto the nomenclature. So when someone comes up to you and says "I want to design a sustainable, carbon aware system that focuses on reducing the operational carbon of my business but also minimises embodied carbon", you will know exactly what they are looking for!
Understand how Google and other search engines use LLMs to gain insights into the semantic meaning of the language in search queries using embedding and cosine similarity.
In this post, I share the top things that resonated with me from the Reset Connect Conference 2023 and crucially some of the topics that I felt were missing – and that we at Scott Logic are actively researching and working on.
For many of us peer review is an everyday part of software development, but why do we bother and how can we do it well? In this post I share my top tips for peer reviewing code.
Spring Boot makes developer’s life easier through autoconfiguration. Even though it's true most of the time, occasionally we come across situations where autoconfiguration makes it harder to understand what is really happening behind the scenes and ends up wasting hours or may be days of developer time. This article is about one such rare occasion where understanding of RabbitMQ got confused with how Spring Boot implemented it behind the scenes.
Using RabbitMQ as it is in Spring Boot works fine. But sometimes it's not enough. This article will explain how to alter the retry behaviour and consume messages concurrently by multiple consumers in RabbitMQ in your Spring Boot Application.
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.
The rapid rise in the consumption or usage of open source hasn’t been met with an equal rise in contribution – to put it simply, there are far more takers than givers, and the challenges created by this imbalance are starting to emerge.
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.
FINOS, in partnership with Linux Foundation Research, GitHub, Red Hat, Scott Logic, and with the support of many other FINOS members, conducted the second annual study to assess the opportunities and potential challenges of consuming, contributing to, and governing open source in financial services. This panel dives into the research's key findings, as well as provides insight into how things have progressed year-over-year.
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.
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.
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?
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.
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.
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!
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.
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.
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.
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.
...or what I should have known before I jumped in and started playing around. In this post I cover logprobs and the "creativity" controls.
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.
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?"
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.
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.
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.
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.
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.
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?
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.
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.
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?
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.
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.
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.
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.
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.
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.
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.
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.
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.