TEE: Teki Editorial Everywhere

[Event] John Wesley didn't have Wi-Fi

2026-09-12T21:14:00.000+00:00

I had the opportunity to attend a workshop in the Methodist Church Synod of North West England, exploring how we can engage people in an increasingly digital world with the church.

What inspired me was how many of the principles discussed are not unique to churches; they are equally relevant to online marketing and digital engagement in general. Thanks to Samuel Rimmer for hosting the workshop and getting us thinking about how we connect with people in a digital world.

The key ideas I took away: The website and social media are often the first things a person encounters before they ever visit a church. They should make the church easy to discover, easy to understand, and easy to approach.

Website — The Front Door

Is your website newcomer-friendly?

The website is often the first impression of the church.

A newcomer should be able to quickly answer: When? Where? What should I expect?

Ask yourself:

Can I find the service time within 30 seconds?
Can I immediately find the address, email and phone number?
Do I know what to expect on my first visit?
Can I see what the church community is like?
Does the website look active and up to date?

Keep it simple

The Jam Experiment illustrates a useful principle: Too many choices can become overwhelming.

Do and Don't

Do	Don’t
Clear Information Immediately Welcoming Photography Clear Invitation Evidence of Activity Mobile-Friendly Design Simple Navigation	Out of Date Content Too Much Information Poor Quality Images Church Jargon Long Blocks of Text Missing Contact Information

Good Examples

https://sojournsterlingheights.com/

https://www.remnantuk.org/

https://www.bramhallmethodists.org.uk/

Social Media Platform

Don't build another notice board

Avoid using social media mainly for:

Event announcements
Weekly notices
Repeated advertisements
Links to information elsewhere

Announcements have a place, but they should not be the whole strategy.

Show people, not just programmes

People want to see:

People
Relationships
Community
Real moments

Show photographs and videos of people talking, serving, worshipping, eating together, helping others and having fun.

Tell a story: Stories create connection. Announcements provide information.

Use richer content: Link < Text < Photo < Video < Live

Algorithm rewards conversations more than announcements

Social media is social.

Don't just post and leave. When people comment: Reply. Ask questions. Continue the conversation.

Timing

Don't post simply because an idea has just occurred to you. Think about when your audience is online.

Potential opportunities:

Early morning: breakfast / before work or school
Early evening: commuting / after work or school

You don't need to be online at that moment. You can schedule the post in advance.

Start small: 15 minutes. Once a week. Every week.

Create something simple. Post it consistently. See what people respond to. Improve gradually.

The 80/20 Rule

Relationship 80%

Promotion 20%

Stories
People
Community
Faith Sharing
Behind the Scenes

Events
Services
Notices
Fundraising

Don't use a big word when a singularly unloquacious and diminutive expression can satisfactorily accomplish the contemporary necessity.

The Most Important Point: People

Digital is only the front door. But when they actually arrive, people make the difference. Interact with people in person.

[Event] JManc 2026

2026-07-10T23:21:27.266+00:00

Yesterday I was so delighted to attend JManc 2026, hosted at AutoTrader's fantastic new office at No. 3 Circle Square.

I started the day with breakfast on the rooftop alongside Lorenzo and Bruce. We had great conversations, enjoyed the beautiful views over Manchester, and it was the perfect way to begin an inspiring day.

Keynote

The event opened with an inspiring keynote by Clare Sudbery, "The Power of Craft: Staying in the Driver's Seat of AI-Assisted Development" She focused on how software engineers should work with AI while continuing to apply professional judgement and craftsmanship.

One statement particularly resonated with me: AI has a planetary brain, but it lacks real-world wisdom.

LLMs have effectively absorbed an enormous amount of human knowledge. They can perform many tasks remarkably well, especially when given the right prompts. However, real wisdom comes from experience and context, something today's AI still cannot truly possess or connect together. It made me think about an important question: How can we tame this titan? It's a question that is worth each of us seriously considering.

Session 1 - How Does AI Impact Software Engineers and Our Future?

Nobody questioned that AI has become remarkably capable. Given clear requirements and well-crafted prompts, AI can produce code with impressive speed and quality.

However, software engineering has never been just about writing code. Requirements analysis, system architecture, integration, production support, communication with stakeholders, operational concerns, and long-term maintenance all remain essential.

If AI reduces the time spent writing code, perhaps developers can spend more time focusing on the bigger picture:

designing better architectures
understanding enterprise environments
improving system reliability
collaborating with business stakeholders
solving complex production issues

One interesting discussion centred around agile estimation. If AI enables developers to implement features much faster, should story points decrease accordingly? Many of us argued that coding has rarely been the true bottleneck in software delivery. The real bottlenecks often lie in:

requirement refinement
dependency management
integration testing
deployment
production issue investigation

AI accelerates implementation, but it doesn't eliminate these challenges.

Session 2 - Is Spring Still Relevant?

With newer frameworks such as Quarkus and Micronaut gaining popularity, it's a fair question.

Certainly, Quarkus and Micronaut offer advantages, particularly around startup time and memory footprint. In reality, several factors continue to make Spring Boot the dominant choice:

enormous community support
a mature ecosystem
abundant learning resources
easier recruitment of experienced developers
years of production experience

Trust also plays a huge role. Many organisations already rely heavily on the Spring ecosystem, including Spring Web, Spring Data, Spring Security, and many other projects.

In particular, Spring Data often becomes deeply embedded within business applications. Once an organisation builds its domain logic around Spring Data, especially across multiple data sources such as relational databases, NoSQL databases, and search technologies like Apache Solr, moving away from the Spring ecosystem becomes extremely difficult.

One exception discussed was ultra-low-latency systems, such as front-office trading platforms, where every microsecond matters. In those specialist environments, lighter frameworks or different technologies may be more appropriate.

Apparently, for the overwhelming majority of enterprise applications, Spring remains highly relevant.

Session 3 - Running Local LLMs for AI Development

Seb shared his experience of using a local Qwen model as an AI coding assistant.

His workflow was particularly interesting. He first uses a proprietary model to generate a development plan. Once the overall plan is ready, he hands the implementation work over to a locally hosted Qwen model, which can work overnight.

This dramatically reduces token costs while keeping source code private. It was a practical example of combining the strengths of proprietary and local LLMs.

Session 4 - Future Java Language Features and Building AI Applications

Desired Future Java Features

Several language improvements generated enthusiastic discussion:

non-nullable types to reduce NullPointerException
named parameters to simplify object construction and reduce reliance on Builder patterns
improved support for lazy constants
better type projections
richer ways to define operations directly on types
easier copying or cloning of records
greater flexibility to mix different programming paradigms within the same source file

Building AI Applications in Java

Several Java AI frameworks were discussed, including:

On the other hand, AI applications also introduce additional concerns, including:

hallucinations
changing model behaviour over time
prompt regressions
model degradation

Reflections

AI is now at the centre of conversations about the future of software engineering, and it was interesting to see how it naturally became part of almost every discussion throughout the day.

It was also wonderful to see more volunteers helping to organise the Manchester Java Community. Growing communities rely on passionate people who are willing to contribute, and it's encouraging to see the community continuing to grow.

A huge thank you to the Manchester Java Community for organising another excellent event, and to AutoTrader for hosting us in their impressive new office. I really enjoyed the day and I'm already looking forward to the next JManc.

S3Mate

2026-01-17T22:09:00.000+00:00

When working with AWS S3, I often receive S3 URLs that are not publicly accessible. These links can't be opened directly in a web browser, and they come in many different formats. For example: https://bucket.s3.amazonaws.com/key or https://s3.region.amazonaws.com/bucket/key

Each time, I had to manually: 1) Figure out which format it was. 2) Extract the bucket and key. 3) Open the AWS Console. 4) Navigate to the correct object. This routine was repetitive and time-consuming.

So I built S3Mate. It's a small desktop gadget that lets me paste any S3 URL, automatically resolves the bucket and key, and quickly shows or operates on the object without switching tools.

The application detail, source code and releases can be found at the repository of the gadget at https://github.com/tekichan/s3mate

Even though S3Mate is a small project, I picked up a few useful lessons along the way.

1. Building Native Desktop Apps with jpackage

I learned how to use jpackage to turn a Java application into a native OS application such as .app for MacOS and .exe for Windows. This relieves the need for end users to install Java or deal with command-line arguments.

2. Using Git Tags for Releases

I now use Git tags to mark exact release points in the project:

git tag <version>
git push origin <version>

I can remove a release:

git tag -d <version>

git push origin :refs/tags/<version>

3. Publishing Releases with GitHub Action

To automate distribution, I used softprops/action-gh-release. This GitHub Action uploads build artifacts directly to GitHub Releases.

S3Mate started as a small personal utility, but it gave me an opportunity to learn how to: 1) package Java desktop app. 2) distribute app across various OS platforms. 3) Automation of Github Releases. Most importantly, it saves me time every day when dealing with various kinds of S3 URLs.

[Event] Accelerate AI with Cloud Run

2025-11-21T23:21:00.002+00:00

I was excited to attend the event Accelerate AI with Cloud Run, organised by Google Developer Group (GDG) North West. Unlike the typical seminar-style tech meetups, this event was so different. It wasn't just about listening, it was about building. The combination of an expert talk and hands-on labs felt perfect for a developer audience.

The workshop started with a session delivered by Richard Bannister from Google. His talk focused on building AI agents on Google Cloud using the Agent Developer Kit (ADK), which is a framework designed to help developers create, deploy, and scale AI-driven agents efficiently.

Key takeaways from the session:

A structured architecture for agent development includes:

Agent Build: Capabilities to design, build and test individual AI agents and multi-agent systems
Agent Ops: Capabilities to deploy, manage, evolve and optimise AI agents
Data Platforms for Agents: Capabilities to acquire, prepare, store and access data for AI agents
Security for Agents: Capabilities to implement guardrails to manage unique risks of autonomous AI system
Governance for Agents: Capabilities to establish policies, frameworks and procedures to govern AI Agents rollout

Open standards of connection: MCP (Model Context Protocol) and A2A (Agent-to-Agent)

After the talk, we dove straight into hands-on labs designed to experience ADK on Google Cloud. Here are the lab links:

Working through the exercises also gave me a glimpse of Google Cloud CloudShell, which now includes a surprisingly fancy Gemini CLI interface. It was fun to explore and definitely felt “state of the art”.

Even though the labs were Google Cloud specific, they introduced several Python tools and libraries that are also useful for development in other platforms:

uv: A new Python package & project manager
FastMCP: A framework for building MCP applications
locust: A powerful and easy-to-use load testing tool
MCP Toolbox for Databases: An MCP server for database interactions

I’m new to Google Cloud, and this workshop really opened my eyes to how fast the technology is moving and how much more there is to explore. I’m excited to keep learning and dive deeper into this area.

References:

Mathematical Animation Engine

2025-10-19T20:18:00.003+00:00

I recently discovered an interesting Python library called Manim. It’s a powerful tool that allows us to create beautiful animations of mathematical concepts and geometric shapes such as polygons, graphs, and functions.

What makes Manim even more exciting is that it can be used directly in Jupyter Notebook. This means I can combine code, text, and animation all in one place — perfect for explaining mathematical ideas in a more dynamic and visual way.

To try it out, I created a simple example using Manim to illustrate the Fourier Transform, one of my favourite topics from university. With just a few lines of code, Manim can generate smooth, professional-looking animations that show how complex waveforms are built from simple sine components.

I’m excited to explore more possibilities with Manim and use it to present other mathematical concepts in a creative and engaging way.

1. Installation


!sudo apt update

!sudo apt install libcairo2-dev \

  texlive texlive-latex-extra texlive-fonts-extra \

  texlive-latex-recommended texlive-science \

  tipa libpango1.0-dev

!pip install manim

!pip install IPython==8.21.0

2. Configuration


import manim as mn

from manim import *



config.media_width = "75%"

config.verbosity = "WARNING"



print(mn.__version__)

3. Fourier Transform Animation


%%manim -qm FourierSineMixed

# Fourier Transform animation: sin(2x) + 2*sin(x + π/4)



from manim import *

import numpy as np



class FourierSineMixed(Scene):

  def construct(self):

    # -------------------------

    # Title

    # -------------------------

    title = Text("Fourier Transform of sin(2x) + 2·sin(x + π/4)", font_size=32).to_edge(UP)

    self.play(Write(title))

    self.wait(0.8)



    # -------------------------

    # Time-domain signal

    # -------------------------

    t = np.linspace(0, 2 * np.pi, 400)

    signal = np.sin(2 * t) + 2 * np.sin(t + np.pi / 4)



    # Time-domain axes (shifted left)

    time_axes = Axes(

      x_range=[0, 2 * np.pi, np.pi / 2],

      y_range=[-3.5, 3.5, 1],

      x_length=6,

      y_length=3.5,

      axis_config={"color": BLUE},

      tips=False,

    ).shift(LEFT * 3.3)



    time_label = time_axes.get_axis_labels(Text("t"), Text("x(t)"))

    time_wave = time_axes.plot(lambda x: np.sin(2 * x) + 2 * np.sin(x + np.pi / 4), color=YELLOW)



    # y-axis numerical labels

    y_min, y_max = -3.0, 3.0

    y_min_label = Text(f{"{y_min:.1f}"}, font_size=22).next_to(time_axes.c2p(0, y_min), LEFT, buff=0.15)

    y_max_label = Text(f{"{y_max:.1f}"}, font_size=22).next_to(time_axes.c2p(0, y_max), LEFT, buff=0.15)



    self.play(Create(time_axes), Write(time_label))

    self.play(Create(time_wave))

    self.play(Write(y_min_label), Write(y_max_label))

    self.wait(0.8)



    # -------------------------

    # Fourier Transform computation

    # -------------------------

    freqs = np.fft.fftfreq(len(t), d=(t[1] - t[0]))

    fft_vals = np.fft.fft(signal)

    magnitude = np.abs(fft_vals) / len(t)



    mask = freqs >= 0

    freqs_pos = freqs[mask]

    mag_pos = magnitude[mask]



    # -------------------------

    # Frequency-domain axes (0–0.4)

    # -------------------------

    freq_axes = Axes(

      x_range=[0, 0.4, 0.05],

      y_range=[0, max(1.0, np.max(mag_pos) * 1.2), 0.2],

      x_length=3.5,

      y_length=3.5,

      axis_config={"color": GREEN},

      tips=False,

    ).shift(RIGHT * 3.0)



    # Axis labels (explicitly positioned)

    x_label = Text("f", font_size=24).next_to(freq_axes.x_axis, DOWN, buff=0.15)

    y_label = Text("|X(f)|", font_size=24).rotate(PI / 2).next_to(freq_axes.y_axis, LEFT, buff=0.35)



    self.play(Create(freq_axes), Write(x_label), Write(y_label))

    self.wait(0.6)



    # -------------------------

    # Bars and labels

    # -------------------------

    bars = VGroup()

    bar_labels = VGroup()

    amp_labels = VGroup()

    bar_width = 0.35



    for f, m in zip(freqs_pos, mag_pos):

      if m < 0.005 or f > 0.4:

        continue



      x = freq_axes.c2p(f, 0)[0]

      y_bottom = freq_axes.c2p(0, 0)[1]

      y_top = freq_axes.c2p(0, m)[1]

      height = y_top - y_bottom



      # Bar itself

      bar = Rectangle(

        width=bar_width,

        height=height,

        color=ORANGE,

        fill_color=ORANGE,

        fill_opacity=0.9

      ).move_to([x, y_bottom + height / 2, 0])

      bars.add(bar)



      # Frequency label (below bar)

      f_label = Text(f"f = {f:.2f}", font_size=20).next_to(bar, DOWN, buff=0.1)

      bar_labels.add(f_label)



      # Magnitude label (above bar)

      m_label = Text(f"{m:.2f}", font_size=20).next_to(bar, UP, buff=0.05)

      amp_labels.add(m_label)



    # -------------------------

    # Transition from time → frequency

    # -------------------------

    self.play(

      Transform(time_wave, bars),

      FadeOut(time_axes),

      FadeOut(time_label),

      FadeOut(y_min_label),

      FadeOut(y_max_label),

      run_time=3

    )

    self.wait(0.6)

    self.play(Create(bars), Write(bar_labels), Write(amp_labels))

    self.wait(1.2)



    # -------------------------

    # Highlight peaks

    # -------------------------

    peaks = []

    for f, m in zip(freqs_pos, mag_pos):

      if 0 < f <= 0.4 and m > 0.05:

        peaks.append(freq_axes.get_vertical_line(freq_axes.c2p(f, m), color=RED))

    if peaks:

      self.play(*[Create(p) for p in peaks])

      self.wait(1.5)



    # -------------------------

    # Cleanup & final text

    # -------------------------

    self.play(

      FadeOut(VGroup(title, bars, freq_axes, x_label, y_label, bar_labels, amp_labels, *peaks, time_wave)),

      run_time=1.2

    )



    end_text = Text(

      "Fourier Transform Reveals Frequency Components",

      font_size=28

    ).to_edge(DOWN).shift(DOWN * 0.5)

    self.play(Write(end_text))

    self.wait(2.5)

Reichstag building, Berlin

2025-08-10T21:18:00.010+00:00

Reichstag building

Berlin, the capital of modern democracy

[Event] JManc 2025

2025-06-13T21:14:00.143+00:00

I had the opportunity to attend JManc again this year—and once more, it was fabulous. The sessions were organic, deeply technical, and full of insights shared by developers across different domains. Here's my wrap-up from the day, highlighting a few memorable sessions and conversations.

1 Tony Wilson, Manchester

30 Years of Java — Jim Gough’s Retrospective

Jim Gough delivered a fantastic keynote on the evolution of Java over three decades. As a Java Champion, his perspective mixed historical insight with a touch of humor and lived experience. Here are some of the milestones he covered:

Applets & Early UI: Java’s original fame came from applets—tiny applications that ran inside web browsers.
AWT & Swing: Early GUI development in Java involved the AWT toolkit, later replaced by the more versatile Swing.
JavaFX: The modern Java UI framework that succeeded Swing. It was eventually removed from the JDK and spun out as an open-source project. While less commonly used in modern web-first development, JavaFX remains powerful for rich desktop applications.
Collections API: Java didn’t always have the familiar List, Map, and Set interfaces. The collections framework demonstrates Java's characteristic of Object Oriented Design.
Generics: Added in Java 5, generics brought compile-time type safety to the language.
Date/Time APIs: The original Date and Calendar classes were messy and mutable. Java 8’s LocalDateTime and related classes (from JSR-310) finally gave Java a clean, immutable time API.
Lambdas & Streams: Java 8 also introduced lambdas, allowing functional programming and vastly simplifying code for iteration, filtering, and transformation.

Jim also asked audience members to share their Java stories. I shared:

“My first Java program was in 2002, working with JCA for encryption and decryption. Even now, I still find JCA reliable. I also used Servlets and JSP—technologies that may be seen as legacy now, but I still find them elegant in their simplicity. I'm hopeful for future UI innovations in Java, especially in areas like JavaFX or beyond.”

Selfie with Jim Gough

Session 1: Quarkus vs Spring

This session compared two popular choices for building backend applications in Java. The discussion was grounded in real-world experience and focused on trade-offs.

Quarkus

Designed for cloud-native workloads and microservices
Emphasizes fast startup times and low memory usage—ideal for containers, serverless, and Kubernetes deployments
Lightweight, developer-friendly with hot reload
Lacks the breadth of built-in libraries and abstraction layers that Spring provides

Spring

Complete and mature ecosystem (Spring Boot, Spring Security, Spring Data, etc.)
Extensive support for dependency injection, configuration, and modularity
XML-based configuration was noted as both flexible and hard to test
Rich in community tooling and documentation

To wrap up, Spring offers completeness and convenience, especially for enterprise systems. Quarkus is leaner and optimised for performance-critical, containerised deployments.

Breakfast

Cappuccino

Session 2: What is TDD?

We started with a simple question: What is Test-Driven Development (TDD)?

The discussion opened up several threads:

TDD isn’t about testing, but about designing with feedback. Writing tests first helps shape APIs and logic with clarity.
Working with legacy code that wasn’t built with TDD in mind is difficult. Often, these systems are tightly coupled and require significant refactoring before becoming testable.
TDD encourages modular design, which makes code more adaptable.
Cultural factors are just as important—communication and team mindset are crucial for successful TDD adoption.
We also explored the difference between TDD (writing tests before code) and BDD (writing specs that describe behavior).

“TDD is not about coding tests—it’s about teamwork, communication and designing cleaner, more reliable systems from the ground up.”

Session 3: Event-Driven Architecture and Apache Kafka

In this session, we explored the principles of event-driven systems, focusing on Apache Kafka.

Key points discussed:

Kafka promotes loose coupling between producers and consumers
It provides durability and scalability, but introduces challenges:
No ordering guarantee across partitions
Possibility of duplicate events
Systems built on Kafka are often stateless, requiring thoughtful design for consistency and orchestration
Event-driven design is powerful for decoupling systems but requires careful thinking around delivery guarantees and idempotency

Hallway Conversations

As always, some of the best insights came outside the sessions.

AI in DevOps

In a conversation with Waqas, we explored ideas around using AI in CI/CD pipelines. I shared that AI could:

Detect flaky or failing tests based on patterns
Recommend release rollbacks or retries
Even automate state-driven workflows, such as those involving Stripe payments

Data Pipeline with Apache projects

With Lorenzo, we dived into data integration stacks in addition to Apache Kafka:

Apache Atlas for metadata and lineage
Apache Storm for real-time streaming
Apache Camel for declarative integration and routing across systems

JManc 2025 Marketplace

Final Thoughts

Big thanks to the Manchester Java Community helpers for organising such a smooth and welcoming event, and to Autotrader, who generously hosted us in a modern, comfortable space.

The JManc covered a wide range of technical and strategic topics. What stood out for me most was how grounded and honest the discussions were—whether we were talking about Quarkus, TDD, or event-driven architecture. All were just about developers sharing, our experiences, our problems, our ideas.

Java is 30 years old and still evolving—and so are we.

[Event] Shape The Future with Lloyds

2024-10-29T21:47:00.000+00:00

I attended the talk called "Shape The Future with Lloyds". It was exciting to see a legacy bank break out of its monolithic shell and dive into Digital Transformation.

The Lloyds Bank team shared insights into their journey of innovation; their commitment and the challenges faced in reshaping such a large institution. It was a great reminder of how iterative progress drives change across any industry.

A special thanks to David Underwood for not only posting this event but also for sharing his experience in making daily multiple deployments possible; a true marker of transformation in action!

Building a Gaming PC: A Personal Journey Through Time

2024-07-28T22:11:00.000+00:00

Building a PC for my son recently brought back memories from my first build over two decades ago. I feel fascinated to see how much has changed and how much has stayed the same. The fundamental concept of assembling a PC remains, but the technology has advanced significantly, making this easier. Here is my lesson learnt during this build.

CPU: AMD Ryzen 5 5600X

The CPU market is still dominated by Intel and AMD, just as it was two decades ago. Unlike the past, where you could simply install a CPU out of the box, modern processors require an efficient cooling system. The additional CPU fan has become a minimal necessity to cool down these powerful processors.

Motherboard: ASUS ROG STRIX B550-F

ASUS remains my favourite brand for motherboards. The advancements here are remarkable. Gone are the PS/2 ports, replaced by USB ports. Sound cards, which were once an essential component, are no longer needed as modern motherboards come with integrated sound. Setting jumpers manually is a thing of the past. In addition, LED decorations add a touch of stylishness, turning the motherboard from a plain piece of metal into a visually appealing entertainment.

Graphic Card: MSI GeForce RTX 3050 LP 6G OC

In the past, a SVGA card with a VGA port was essential for any build. Today’s motherboards come equipped with HDMI ports, but for a gaming PC, a dedicated graphics card with a powerful GPU is indispensable. GPUs are not only crucial for 3D games but also play a significant role in machine learning programs.

Storage: Crucial BX500 SATA SSD 1TB

Storage technology has dramatically transformed. The bulky SCSI 3.5" HDDs have been replaced by sleek SATA 2.5" SSDs. SSDs are lighter, faster, and more shock-resistant. CD-ROM drives and 1.44" floppy drives have vanished in modern PCs, thanks to the widespread adoption of USB storage. And yes, jumpers are no longer a part here either.

Network Card: TP-Link Archer TX55E

Both my old and new builds required external network cards. The network card was previously essential for Ethernet connections. Today, the motherboard comes with a built-in Ethernet port, and the network card I added provides WiFi and Bluetooth connectivity.

OS: Windows 11 Home

Setting up the operating system was another area where I noticed significant improvements. Two decades ago, I spent hours installing Windows 98 from the OS CDs as well as hardware drivers' CDs. This time I installed Windows 11 from the USB drive and all drivers were automatically recognised by the latest OS. The system was ready to use almost instantly.

Building this PC today was still a delightful experience, bridging the gap between past and present. It was my personal testament to how far technology has come.

Horse Racing Game by PyGame

2024-07-19T23:16:00.006+00:00

My little son inspired me 🤗 to create a Horse Racing game using Pygame, based on his original Scratch game. 🎮🐴

This project is not only a simple game but also serving as a step-by-step tutorial to help kids and beginners transition from Scratch to Python programming.

Find the full game and tutorial: https://github.com/tekichan/py_horse_racing

Let’s encourage the next generation of coders! 💻✨

[Event] JManc (28th June 2024)

2024-06-29T14:22:00.002+00:00

My Sharing about JavaFX

Attending JManc, an unconference organised by Manchester Java Community and hosted at Auto Trader's offices, was an exciting experience. This unique event demonstrating the essence of participant-driven learning and collaboration, set the stage for a series of engaging and enlightening sessions.

Propose and vote for topics

In the morning, we proposed topics using sticky notes. Afterward, we voted on these topics with dots, shaping the day's agenda based on collective interest. This process itself was a testament to the community's diverse interests and expertise.

Breakfast

Keynote by Helen Scott

The unconference kicked off with a keynote by Helen Scott from JetBrains. Helen's talk centered on AI, a topic so crucial and timely that, as she humorously noted, audience would have thrown her out of the window if she did not speak of AI. Her insights into AI's impact on development and the future of programming set a thought-provoking tone for the day.

New Features

The next session delved into the latest features in Java, highlighting enhancements that developers can leverage to improve their productivity. We explored the new switch syntax, Records, new Collections APIs, Java Modularity, and the Java Native Interface. Each feature was dissected to understand its benefits and potential use cases.

Troubleshooting Applications in Containers

Troubleshoot in Containers

This session focused on the challenges and solutions for troubleshooting Java applications running in containers. We covered stress testing with JMeter, analysing heap dumps, configuring Garbage Collection, and the division of labor between image building and container deployment. The practical insights shared were invaluable for anyone working with containerised Java applications.

Lunch

JavaFX, Home Automation and Stable Diffusion

JavaFX

After lunch, I had the pleasure of partnering with Neil Smith and Swapnil Gaikwad for a session on JavaFX. We discussed a range of applications, from home automation and image recognition to Java and Python integration, text-to-image generative AI, and game development. The collaborative nature of this session highlighted the versatility of JavaFX and its potential in various domains.

Java vs Other Programming Languages

In this session, we compared Java's capabilities with those of other popular programming languages like Kotlin and Python. We discussed Java's unique advantages, such as its robustness, extensive ecosystem, and long-term stability, as well as factors influencing its popularity.

Tiered Compilation

The final session of the day tackled Java's Tiered Compilation, an advanced topic that delved into the intricacies of the Java compiler. We explored how developers can fine-tune their applications for optimal performance by understanding the secrets of Java's compilation process.

Fault Injection - another interesting topic

JManc was a resounding success. Every participant brought their ideas, experiences, and knowledge, contributing to a vibrant and dynamic setup. The unconference format allowed for deep dives into a wide range of topics, fostering both learning and collaboration. A big thanks to the organisers and every helper who made this event possible. JManc was a fruitful activity that everyone is definitely looking forward to it next year.

References

Stable Diffusion User Interface for Java

2024-03-18T23:00:00.011+00:00

Happy to share my recently developed GUI application built entirely in Java! The app, called SDUI4J, serves as an intuitive platform for Text-To-Image and Image-To-Image generation, seamlessly integrated with Stable Diffusion APIs.

Using JavaFX along with FXML, I've crafted a modern and structured GUI, ensuring a user-friendly experience while tapping into Java's full potential in the realm of Generative AI.

I'm passionate about discovering Java's capabilities in the field of AI, and this project is a testament to that. I'm excited to continue exploring the convergence of Java and AI.

If you're interested in learning more about this project or exploring potential collaborations, feel free to reach out. Let's drive Java forward in Generative AI together!

[Event] Live Coding: Functional Refactoring in Java

2024-01-31T23:00:00.002+00:00

Just experienced a fantastic moment at the deep-dive live coding session hosted by Matias Salerno at Auto Trader UK this evening. We were watching the live transformation of imperative legacy Java code into a concise and declarative Functional Programming style. Another interesting thing is how participants with background of JS and Python grasped more OOP concepts in Java during the session.

Matias Salerno (right)

Kudos to Manchester Java Community for organising such a hands-on session, and not to mention, the delicious refreshments!

Event: Manchester Coding Dojo

2024-01-11T22:35:00.002+00:00

Coding Dojo

Thank you to Codurance for organising Coding Dojo to learn Test Driven Development. We did not only taste TDD and JS but also explored Copilot, Team Collaboration, Project Management, Methodology, etc. Networking seemed endless after the talk. No wonder why this city became a hub of talents.

Outside Department Bonded Warehouse

Inside Department Bonded Warehouse

Monty Hall Problem Simulation

2023-12-25T22:22:00.001+00:00

"""

This is a simulation of Monty Hall Problem.

https://en.wikipedia.org/wiki/Monty_Hall_problem

Suppose you're on a game show, and you're given the choice of three doors: Behind one door is a car; behind the others, goats.

You pick a door, say No. 1, and the host, who knows what's behind the doors, opens another door, say No. 3, which has a goat.

He then says to you, "Do you want to pick door No. 2?" Is it to your advantage to switch your choice?

"""

import random

NUM_DOORS = 3 # three doors in the game

MAX_ROUND = 10000 # number of rounds for statistics

change_win_count = 0

for _ in range(MAX_ROUND):

# randomly to put a car behind a door

car_door = random.randint(0, NUM_DOORS - 1)

# the player firstly selects a door

player_first_guess = random.randint(0, NUM_DOORS - 1)

# the host opens another door without a car

host_door = random.choice([

x for x in range(NUM_DOORS) if x != player_first_guess and x != car_door

])

# the option if the player changes his mind

player_second_guess = random.choice([

x for x in range(NUM_DOORS) if x != player_first_guess and x != host_door

])

# count the win if the second guess is correct

if player_second_guess == car_door:

change_win_count += 1

# Print the statistics result

print("Win percentage if you switch the choice is {r:.2f}%".format(

r=(change_win_count * 100) / MAX_ROUND))

Small Step, Giant Leap

2023-09-08T12:47:00.002+00:00

Looms in Quarry Bank

Check out these two antique looms displayed in Quarry Bank of National Trust

Although they look similar, the left one comes with a tiny gadget called Flying Shuttle. This small improvement dramatically increased the productivity over tenfold. John Kay might not have even imagined how much his invention would become a catalyst for the Industrial Revolution and have profound effects on the world history.

You know what? Keep dreaming, innovating, and moving ahead. You never know your next small step could be a giant leap for mankind.

Pluses and Minuses: How Math Solves Our Problems

2023-09-06T13:04:00.000+00:00

Pluses and Minuses: How Math Solves Our Problems

"Pluses and Minuses: How Math Solves Our Problems" by Stefan Buijsman is a thought provoking book about the role of Mathematics in our daily life.

The book starts with examples of Google Map and Netflix to present that Maths is not only an abstract exercise in a classroom but also closely related with us everyday. Following that, it describes how human being interpret Maths and its development along the history in various cultures.

The later chapters demonstrate about the history and applications of two advanced topics, Calculus and Probability. The last topic is about graph theory and explores its usage in navigation, streaming service, cancer treatment and social media.

The last chapter is not only a conclusion but also rethinks the nature of Maths and how we correctly and mistakenly apply it in our daily experiences.

While the book contains a few content describing Maths formula and theorems in this book, it primarily focuses on the interactions between Maths and human being, including historical context, cultural significance, and practical uses. They sound quite engaging. They also reflect how deeply the author understands Maths in the position of our society.

One more thing I learnt from this book is how to illustrate some complex concept, e.g. a brand new system solution, to audience regardless of their background. Like this book, we can start an immediate example which is related with the concept, then trace what if the concept is not in place, some stories of its development (not a big bang, not a surprise) and behind the scenes, and finally bring out how the complication leads opportunity. This approach is to package the new concept to sound easier, familiar and more pleasant.

In summary, this book is such captivating and accessible that effectively bridges the gap between Maths and our everyday life. The author is able to connect mathematical concepts with real-world examples, historical context, and cultural significance makes this book a compelling read for anyone interested in understanding the pervasive role of mathematics in our society.

Event: Developer Productivity Engineering: What's in it for me?

2023-08-17T22:04:00.003+00:00

Manchester Java Community hosted another great session in Thoughtworks. The speaker is Trisha Gee, co-author of the renowned book Head First Java.

The speaker pointed out that the productivity of developers did not mainly come from individual developer themselves but from the organisation which offers productive environments or not. The factor includes work space size, quietness, privateness, any diversion or needless interruption.

On technology side, productivity can be improved by consistency and reliability of builds. Very fast feedback can improve productivity and quality, thus increase revenue, reduce cost and improve brand.

References:

Trisha Gee and Head First Java

Author Signature

Inside Thoughtworks

Outside Thoughtworks

Event: Be a better Java developer, learn faster and get more results!

2023-07-13T22:25:00.003+00:00

I joined a meetup brought by Manchester Java Community at Roku's office. The topic is Be a better Java developer, learn faster and get more results!

The speech started with the dynamic trios:

Fire your neurons: learn by doing
Force to practise
Frequent action

The captivating speaker also shared back stories of recruitment and his own secret of Reputation Formula, i.e.,

Career Reputation = (Focus * Visibility * Action * Skill [XP] * Giver * Responsibility * Consistency) / ((Me-me-me) * Lies^2 * Difficult)

In Q&A session, we delved into burning questions like the future of AI in developer jobs and whether Java will be the next COBOL.

Thank you very much to Bruno Souza for his fascinating speech and inspirational career advice.

Ethical Hacking 101

2023-06-27T09:10:00.003+00:00

In today's digital landscape, software security is paramount. To safeguard applications from cyber attacks, developers must embrace Ethical Hacking—an innovative approach that empowers them to uncover vulnerabilities and strengthen security measures.

Ethical Hacking involves adopting the mindset of malicious hackers to identify weaknesses and fortify defences against unauthorised access, data breaches, and other threats. By integrating this practice into the coding process, developers gain valuable insights, proactively mitigating risks and creating more robust and secure software systems.

I took a basic lesson from Snyk about Ethical Hacking, which helps me consider security measures in coding.

Process

Plan & Prepare (Reconnaissance phase)
Scan & Enumerate
Exploit
Analyse & Report
Communicate & Collaborate
Continuous Education & Professional Development

Tools

Nmap: network scanner
Burp Suite: security testing of web applications
Metasploit: penetration tests
Wireshark: packet analyser
Maltego: intelligence and forensics, graphical link analysis for real-time data mining.
Snyk: scan, prioritize, and fix security vulnerabilities of codes
John the Ripper: password cracking tool
Wappalyzer: Find out what websites are built with
Kali linux: for digital forensics and penetration testing

Best Practices

Obtain permissions before conducting any testing
Follow all relevant laws and regulations
Do not use tools or techniques that could cause damage or disruption
Use a risk-based approach
Document your findings and provide a report to the owner

XSS (Cross-Site Scripting)

Cross-Site Scripting attacks are a type of injection, in which malicious scripts are injected into otherwise benign and trusted websites.

Example: Try to fill in

[Totally Safe Link]

(javascript&#58document;cookieStore.g et('super_secret_cookie'8#41;.then((e&#

41; =>

{document.getElementsByClassName('v-text-field _slot'8#41;

[1].childNodes[1].value='${e.namel = $

{e.value}

*;document.getElementsByClassName('v

-text-field slot'8#41;

[1].childNodes [1].dispatchEvent(new

Event ('input')8#41;;document.getEl ementsByClassName'v-text-field _slot'8#41;

[1].nextElementSibling.childNodes[0].clic k(8#41;}8#41;

Then conduct Prototype Pollution, says caused by lodash. See detail at https://github.com/Kirill89/prototype-pollution-explained/blob/master/README.md

Path Traversal

A path traversal attack (also known as directory traversal) aims to access files and directories that are stored outside the web root folder.

Example: Send a request like /82e82e/82e82e/82e82/8282/82e%2e/etc/passwd , due to some libraries like st@0.2.4

Vulnerability Disclosure Program & Bug Bounty

Hackerone
Bugcrowd
Intigriti
Promote responsible disclosure and incentivizing bug hunting
Identify and address security weaknesses before they can be exploited by malicious actors
Improve the overall security of software and systems
Include scope and objectives, methodology, findings and vulnerabilities, risk assessment and severity ratings, and recommendations for mitigation
Consider honesty, accuracy, confidentiality. and respect for 3rd-party agreement

Resources

Driving Test was passed

2022-12-07T13:00:00.004+00:00

Hurray! I passed the driving test!

Driving isn't a rocket science, yet it's still a challenge, especially when there is noise surrounding your determination, such as "You're a coder, not a driver"; "You're too old to learn driving"; "You're going to a centre with the least passing rate", etc. Leaving your comfort zone can be intimidating, but when you take a leap, you open yourself up to new experiences, opportunities and growth.

Embrace a new change with an open mind and a positive attitude. You'll be pleased at what you can achieve.

Merry Xmas 2022

2022-12-01T17:00:00.027+00:00

Lunch @ The Fox

I felt trilled when actually meeting up the colleagues who I used to meet online only. The tradition Christmas party in a tradition pub made our gathering warm.

Event: Comparing Native Java REST API Frameworks with Matt Raible

2022-10-27T10:24:00.003+00:00

Manchester Java Community hosted a meetup with a fantastic speaker Matt Raible in Infinity Works's office. Matt compared the startup performance and memory usage of Spring Boot, Micronaut, Quarkus and Helidon frameworks. He built a REST API application secured by OAuth 2.0 and ran the application in Docker with the four frameworks respectively.

His slides and related resources can be found at Comparing Native Java REST API Frameworks - Manchester JUG 2022. Here is my thought after the talk:

Java is still hugely popular and widely used (Yay!). The community should contribute to the language to encourage more younger generation to adopt it.
Use SDKMAN to manage multiple JDK in a local computer
Use HTTPie which is better than cURL for testing API
Test OpenID Connect requests and debug responses with OpenID Connect debugger
Build optimized Docker images for your Java applications with Jib
Compare with startup time which does matter for Serverless
Take MicroProfile as the baseline platform for Java microservices architecture.
Secure API with OAuth 2.1 to capture best practices of 2.0 with extensions
Spring provides much better testing support. It can mock up all the things before you reach endpoints. Spring has the strongest and dominent community and ecosystem.
Quarkus does not need compilation again when changed
Frameworks ease the development. On the other hand, the sophisticated frameworks hide the complexity which developers may not deep-dive it. Thus it may incur a risk of unwanted side effects of other libraries they are not aware of.
Spring framework comes with other sister projects like Spring Data and Spring Security. It is not straightforward to migrate from Spring due to dependency of sister projects.

Unique Random Numbers

2022-09-26T10:49:00.001+00:00

Thanking Java's stream feature, it is easy to generate a list of unique random numbers. For example, we want to pick up 6 lucky numbers for Lotto which ranges from 1 to 59.

new Random().ints(1, 59+1).distinct().limit(6).sorted().boxed().collect(Collectors.toList());

J Forum

2022-08-31T17:07:00.084+00:00

I joined an online conference called J Forum which explored the current state of Java ecosystem, ahead of this September's release of Java 19. Here are some takeaways:

Garbage Collector Ergonomics. There are several GC selections for various situations. Here are the recommendations:

Serial: single core, smal heaps
Parallel: multi-core small heaps; batch jobs with any heap size
G1: responsive in medium to large heaps (request-response/DB interactions); only when processors 2+ and memory 1728MB+
Z: responsive in medium to large heaps (request-response/DB interactions); JDK 17+; Pause < 1ms
Shenandoah: responsive in medium to large heaps (request-response/DB interactions); JDK 17+; Pause <10ms

GC Tuning does not only rely on setting heap size (-Xmx for well-sized workloads, -XX:MaxRAMPercentage for workloads to be scaled along container memory limits, -XX:ActiveProcessorCount), but also understanding the workload. You should select appropriate GC and have enough CPUs (check Runtime.getRuntime().availableProcessors() and -XX:+PrintFlagsFinal)
Analyze VM data with JDK Flight Recorder (JFR)
Contract Testing for testing an integration point by checking each application in isolation to ensure the messages it sends or receives conform to a shared understanding that is documented in a "contract".
Introduction to JCP
References:

TEE: Teki Editorial Everywhere

[Event] John Wesley didn't have Wi-Fi

Website — The Front Door

Is your website newcomer-friendly?

Keep it simple

Do and Don't

Good Examples

Social Media Platform

Don't build another notice board

Show people, not just programmes

Algorithm rewards conversations more than announcements

Timing

The 80/20 Rule

The Most Important Point: People

[Event] JManc 2026

Keynote

Session 1 - How Does AI Impact Software Engineers and Our Future?

Session 2 - Is Spring Still Relevant?

Session 3 - Running Local LLMs for AI Development

Session 4 - Future Java Language Features and Building AI Applications

Desired Future Java Features

Building AI Applications in Java

Reflections

S3Mate

1. Building Native Desktop Apps with jpackage

2. Using Git Tags for Releases

3. Publishing Releases with GitHub Action

[Event] Accelerate AI with Cloud Run

Mathematical Animation Engine

1. Installation

2. Configuration

3. Fourier Transform Animation

Reichstag building, Berlin

[Event] JManc 2025

30 Years of Java — Jim Gough’s Retrospective

Session 1: Quarkus vs Spring

Session 2: What is TDD?

Session 3: Event-Driven Architecture and Apache Kafka

Hallway Conversations

AI in DevOps

Data Pipeline with Apache projects

Final Thoughts

[Event] Shape The Future with Lloyds

Building a Gaming PC: A Personal Journey Through Time

CPU: AMD Ryzen 5 5600X

Motherboard: ASUS ROG STRIX B550-F

Graphic Card: MSI GeForce RTX 3050 LP 6G OC

Storage: Crucial BX500 SATA SSD 1TB

Network Card: TP-Link Archer TX55E

OS: Windows 11 Home

Horse Racing Game by PyGame

[Event] JManc (28th June 2024)

Keynote by Helen Scott

New Features

Troubleshooting Applications in Containers

JavaFX, Home Automation and Stable Diffusion

Java vs Other Programming Languages

Tiered Compilation

References

Stable Diffusion User Interface for Java

[Event] Live Coding: Functional Refactoring in Java

Event: Manchester Coding Dojo

Monty Hall Problem Simulation

Small Step, Giant Leap

Pluses and Minuses: How Math Solves Our Problems

Event: Developer Productivity Engineering: What's in it for me?

References:

Event: Be a better Java developer, learn faster and get more results!

Ethical Hacking 101

Process

Tools

Best Practices

XSS (Cross-Site Scripting)

Path Traversal

Vulnerability Disclosure Program & Bug Bounty

Resources

Driving Test was passed

Merry Xmas 2022

Event: Comparing Native Java REST API Frameworks with Matt Raible

Unique Random Numbers