The first year

When I first joined, I was completely new to the industry. At the time, I was much more of a follower than a technical leader. Most of my work involved navigating an existing codebase rather than designing new systems, and that codebase was largely built on legacy PHP 5, ES5 JavaScript, and plenty of jQuery. It wasn’t the modern stack I had been exposed to in school or through my personal projects, and learning to work effectively within an established system was a challenge in itself.

Like any junior developer, I made my fair share of mistakes. Some refactors turned out to be far more disruptive than I anticipated, including removing features that members of the Eclipse community depended on (oops). Those experiences taught me the importance of understanding existing systems, respecting backwards compatibility, and recognizing the impact that even seemingly small changes can have on real users.

That experience has stayed with me. It fundamentally changed how I approach changes to public-facing software and made me much more disciplined about semantic versioning, backwards compatibility, and carefully considering the impact of every release.

Later that year, I was given the opportunity to implement a major website redesign. Looking back, I made several architectural decisions that I would approach differently today. As the project evolved, some of those early choices became increasingly costly to maintain. It was a humbling experience, but one that shaped how I think about software architecture, technical debt, and the importance of making decisions that can scale beyond the immediate needs of a project.

The middle years

In the middle years, I became more comfortable making technical decisions and helping steer projects in a particular direction. I began taking ownership of several libraries and websites, and even spearheaded major refactors, including the Foundation’s Membership Portal.

The Membership Portal is the Foundation’s dashboard application that allows members to view their project activity and manage their relationship with the Foundation. To put it lightly, the application had significant performance challenges. The refactor replaced a convoluted collection of useEffect-driven logic with Redux Toolkit, eliminating unnecessary re-renders from the application and significantly simplifying the overall codebase.

During this period, we also adopted TypeScript across our libraries, introduced unit testing, and invested in better developer and user documentation through Storybook. These years were about taking the lessons I had learned early on and applying them, moving from simply contributing to projects toward actively shaping their technical direction.

The final year

An unexpected brand refresh came into my lap, and I had to move quickly. There simply was not enough time to completely rethink the architecture, so, reluctantly, we repeated some of the same mistakes from previous redesigns. However, as time went on, we continued working behind the scenes to gradually turn that refresh into something more mature and maintainable.

I’ll admit it: this was one of the most challenging projects I worked on, and I never quite felt like I fully solved it. We were dealing with a legacy CSS and component library that had been around for more than 14 years. It was deeply coupled to nearly every website operated by the Foundation, making any significant change a difficult balancing act.

Despite those challenges, we made significant progress. Rather than continuing to evolve the legacy system, Solstice Assets, indefinitely, we began breaking it apart into three distinct initiatives:

• A new CSS theme: lightweight, preferably built with vanilla CSS, and easier for projects to adopt independently.
• A JavaScript API client: something that could eventually be offered as a service to the community, allowing developers to build their own experiences without needing to understand or maintain API schemas.
• A component library: Solstice Components, which was the only one of these initiatives to reach completion.

Solstice Components became a modern, framework-agnostic component library built with web components and Lit, allowing these components to be used across websites regardless of their underlying technology stack. See my post about it here .

We also took the opportunity to properly deprecate major portions of the Hugo theme. We moved from a messy 0.x.x version history that contained three separate brand refreshes in the same major version to proper semantic versioning, releasing 1.0.0, 2.0.0, and 3.0.0. This allowed us to better communicate breaking changes, reduce maintenance complexity, and avoid carrying years of accumulated technical debt forward.

If only I had more time to do the same with Solstice Assets. It remains one of the biggest pieces of unfinished work, and I hope the next person who takes ownership of it can see it through. The foundation has been laid, the problems are better understood, and I believe it is now in a much better position to be transformed into something more modern and maintainable.

Conclusion

Looking back, my time at Eclipse Foundation has been a journey of growth. I joined as someone still learning how to navigate a large and unfamiliar codebase, and I leave having had the opportunity to shape the architecture, tools, and practices that support the Foundation’s work.

Not every challenge was solved perfectly. Some things remain unfinished, and some decisions were made under constraints that required compromise. But I am proud of the progress we made, the foundations we built, and the people I had the opportunity to work alongside.

The biggest lesson I am taking away is that engineering is rarely about creating something perfect from the beginning. It is about continuously improving, making thoughtful decisions, and leaving systems in a better state for the people who come after you.

Thank you to everyone at Eclipse Foundation who trusted me, challenged me, and helped me grow over these past four years. It has been an incredible chapter of my career, and I am excited to see what comes next.

We decided it was time to refresh and reorganize the documentation to better align with the 3.0.0 release, which incorporates the major Eclipse Foundation brand refresh from last year.

How it is organized

We have reorganized the documentation into several comprehensive sections:

• Shortcodes: A catalog of all the shortcodes included in the theme, with detailed documentation for each one, including usage guidelines, code examples, and visual demos.
• Front Matter: A reference for all the front matter parameters that can be used to customize the behavior and appearance of an individual webpage, with examples of how to use them in your content files.
• Configuration: A reference for all the configuration options that can be used to customize the behavior and appearance of your entire website, with examples of how to use them in your Hugo config file.
• Examples: A collection of examples and recipes to demonstrate how to use the theme’s features.
• Changelog: A detailed log of all the changes, improvements, and bug fixes made to the theme over time.

We also added a showcase section to highlight websites built with the Hugo Solstice Theme. This should provide inspiration and ideas for how to use the theme in different ways.

Our commitment to providing high-quality libraries

The Hugo Solstice Theme is one of many libraries and tools we maintain to support the Eclipse community. We are committed to delivering high-quality, well-documented libraries that are easy to use and integrate into your projects. We will continue investing in improved documentation, ongoing enhancements, and user support to ensure you have the best possible experience with our libraries and tools.

Consider using the Hugo Solstice Theme for your next website

If you’re looking for a modern, flexible, and user-friendly theme for your next website, the Hugo Solstice Theme is a great choice. It enables you to quickly create a professional-looking site with minimal setup while offering extensive customization options to suit your specific needs. Whether you’re building a project site, a Working Group website, or another type of web presence, the Hugo Solstice Theme helps you get started quickly, delivers an excellent experience for your visitors, and includes the Eclipse Foundation brand styling by default.

Get started with Hugo Solstice Theme by bootstrapping your site using the starter boilerplate project , or install Hugo Solstice Theme directly from NPM .

The old library served us well - here’s why we built something better

The old component library, Solstice Assets, was built on top of a combination of jQuery, vanilla JavaScript, LESS stylesheets, and Mustache templates. While it served us well for many years (10+), it had several issues:

1. Portability: The legacy component library was tightly coupled to eclipse.org’s global styles, making it difficult to reuse components on other sites without style conflicts. It also introduced significant CSS overhead, increasing the consumer’s bundle size.
2. Distribution: Solstice Assets could be included either via NPM or by downloading build artifacts from eclipse.org. The NPM option required a fairly strict build setup, often forcing your tooling to be built around the library’s Webpack configuration rather than your own, which reduced compatibility with other tools. The downloadable artifacts lacked versioning, leading to risk of instability when updates were made.
3. Scope: The library tried to do too much. It bundled a full CSS framework (Bootstrap 3), global styles, and a large set of components, making it difficult to adopt selectively or use only what you actually needed. While this worked for sites already aligned with our styles, it created friction for those with their own independent design systems and visual identity.

These issues introduced significant barriers to entry for many developers who aren’t front-end specialists. To better support the Eclipse community, we had to go back to the drawing board and build something more portable, easier to integrate, and focused purely on components. We had to build a component library that was truly for everyone in the Eclipse community, regardless of their technical expertise or the tech stack they were using.

Introducing our new component library

Our new library, Solstice Components , is built on Web Components, a native web platform feature that allows us to define custom HTML elements. This makes the components extremely simple to use: just drop them into your markup like any standard HTML tag. No build step required, it works out of the box.

Web Components are designed to integrate into any web page, regardless of the underlying technology. This means you can use our components in a React app, a WordPress site, or even a plain HTML page without additional setup¹.

They also benefit from style encapsulation, so component styles don’t clash with your website’s styles. This improves portability and ease of use.

Examples

To display a list of project adopters for a particular project, you can simply add the following HTML to your webpage:

1

<efsc-project-adopter-logo-list projectid="ecd.openvsx"></efsc-project-adopter-logo-list>

If you want to display a working group’s member organizations, you can add the following HTML:

1

<efsc-member-logo-list type="working-group" collaboration="adoptium"></efsc-member-logo-list>

To display a list of events, you can do the following:

1
2
3
4
5

<efsc-collection pagesize="2" autoscroll="true">
  <efsc-event-filters></efsc-event-filters>
  <efsc-event-list></efsc-event-list>
  <efsc-pagination maxvisible="5" justify="center"></efsc-pagination>
</efsc-collection>

Try it out

If you’re interested in trying out the new Solstice Components, you can find the documentation and installation instructions on our website . It can be installed via NPM or you can find embeds to include the library directly in your HTML from a CDN.

Conclusion

This is just the beginning. We’ve built the foundation for something better, and we’re counting on your feedback to keep improving it. Try the new component library in your existing site. We think you’ll notice the difference immediately. And if you have ideas for new components or improvements, we’d love to hear you by creating an issue ! This library is for the entire Eclipse community.