Node.js for Mobile

In the heart of San Francisco, the future of transportation is unfolding. Over the past month, the city's streets have become a testing ground for autonomous taxis. We now find ourselves at a pivotal intersection of technology and transportation. Software engineering visionaries know that embracing this technological shift means more than acknowledging IoT and AI. It's about identifying the hurdles these vehicles might encounter and steering the direction for future innovations. 

In this article, we'll delve deep into the genesis of driverless cars, highlighting the technical triumphs and the bumps they've encountered along the way. From the ethical dilemmas posed by AI biases to the promise of cutting-edge solutions like Liquid Neural Networks, join us as we navigate the intricate landscape of autonomous taxis, offering critical and forward-thinking insights. Strap in for a ride through autonomous taxi's past, present, and future. 

## The Genesis of Driverless Cars

The allure of autonomous cars dates back to the 1920s, a time when rudimentary experiments and remote control technologies ignited imaginations. In 1925, [New York witnessed the demonstration of the first radio-controlled car](https://content.time.com/time/subscriber/article/0,33009,720720,00.html), the "American Wonder," 30 years after the invention of radio, transmitting Morse Code. Nearly a century later, fleets of robotaxis are swarming cities due to advancements in AI coupled with over [100 billion dollars of investment](https://www.bloomberg.com/news/features/2022-10-06/even-after-100-billion-self-driving-cars-are-going-nowhere?in_source=embedded-checkout-banner) in the industry. In 2016, Singapore became the first to launch an autonomous taxi service, followed by Uber in Pittsburgh[, in the USA](https://techcrunch.com/2016/09/14/1386711/). Since then, various trials have emerged globally, with safety drivers in some instances and fully autonomous operations in others, spanning regions from China to Russia and beyond. 

## The Bumps on the Road: Post-Introduction Challenges

While exhilarating, the promise of a driverless future hasn't been without its setbacks. Despite safety concerns, this August marked a turning point in driverless car history as San Francisco decided to permit 24/7 driverless taxi operations in the city. Within days, there were a series of public mishaps. Ten Robotaxis, operated by Cruise, [halted unexpectedly on bustling streets](https://twitter.com/friscolive415/status/1690281516935589888?s=20) due to lost contact with mission control. A Cruise autonomous car found itself [entangled in freshly poured](https://www.nytimes.com/2023/08/17/us/driverless-car-accident-sf.html) cement. Another Cruise robotaxi [collided with a fire truck, leaving one injured](https://www.theverge.com/2023/8/18/23837217/cruise-robotaxi-driverless-crash-fire-truck-san-francisco), and most recently, [two cruise taxis delayed an ambulance transporting a car accident victim](https://www.nytimes.com/2023/09/02/technology/driverless-cars-cruise-san-francisco.html) to hospital who later died. These episodes underscore the complexities of real-world driving scenarios.   

## The Edge Case Enigma

As open source veterans and maintainers for multiple software programs, including PyTorch on Windows, we understand the difficulties of dealing with edge cases, especially in unpredictable environments. In the context of autonomous vehicles, this unpredictability manifests as unique situations that fall outside the parameters of training data. Whether it's sudden weather changes, unexpected pedestrian behavior, or unforeseen road obstructions, these scenarios can present significant challenges for autonomous systems. In a [recent blog](https://cacm.acm.org/blogs/blog-cacm/275660-face-it-self-driving-cars-still-havent-earned-their-stripes/fulltext), Gary Marcus, CEO & cofounder of the Center for the Advancement of Trustworthy AI, said: "Scaling up to driving everywhere all the time without a serious, well-vetted solution to the edge case problem was insane; it was quite literally an accident (or series of accidents) waiting to happen." He also touched on earlier reflections from some of the first autonomous driving tests in 2016, saying, "If you put them in clear weather in Palo Alto, they're terrific … All the drivers are relaxed; you try it in New York, and you see a whole different style of driving. The system may not generalize well to a new style of driving." 

## The Ethical Crossroads: Unmasking AI's Biases

In addition to concerns with edge cases, [a recent study](https://arxiv.org/pdf/2308.02935.pdf) unveiled unsettling biases in some autonomous systems. The research tested over 8,000 images using eight AI-powered pedestrian detection systems. The research pointed to discrepancies in how accurately self-driving car sensors detect children and people with darker skin. These findings underscore how technology can perpetuate real-world inequality if ethics and inclusivity are not deliberately centered in AI design.  

Dr. Jie Zhang, one of the study's authors, said in a [press release](https://www.kcl.ac.uk/news/driverless-cars-worse-at-detecting-children-and-darker-skinned-pedestrians-say-scientists). "Car manufacturers don't release the details of the software they use for pedestrian detection, but as they are usually built upon the same open-source systems we used in our research, we can be quite sure that they are running into the same issues of bias." However, [a spokesperson for Waymo told Gizmodo](https://gizmodo.com/driverless-cars-worse-kids-dark-skinned-people-study-1850770302?utm_source=vip) that they also include lidars and radars as opposed to cameras alone.   

## Liquid Neural Networks: A Beacon of Hope

In the face of these challenges, [innovations like MIT's Liquid Neural Networks (LNNs)](https://venturebeat.com/ai/how-mits-liquid-neural-networks-can-solve-ai-problems-from-robotics-to-self-driving-cars/) offer a glimmer of hope. Their potential to handle novel scenarios better than traditional AI systems makes them a promising solution for autonomous vehicles' challenges.  

LNNs, inspired by biological neurons, are compact and highly adaptable. A striking testament to their efficiency is their compactness: traditional networks might require around 100,000 neurons for tasks like lane-keeping, but an LNN achieved the same with just 19 neurons.  

Daniela Rus, the director of MIT CSAIL, shared, "The inspiration for liquid neural networks was thinking about the existing approaches to machine learning and their fit with safety-critical systems like robots and edge devices."   

Moreover, LNNs have showcased their adaptability in real-world scenarios. Researchers trained LNNs for object detection on video frames taken in woods during summer. Only the LNNs maintained high accuracy when tested in different seasons, while other neural networks faltered. Rus observed, "Only the liquid networks were able to complete the task in the fall and winter because these networks focus on the task, not on the context." This adaptability is crucial, especially when considering the biases highlighted in the abovementioned study. Technologies that can adapt to diverse scenarios without being influenced by the context can potentially reduce biases and ensure safer autonomous operations.  

## Conclusion

The journey toward autonomous vehicles is a blend of triumphs and trials. As we navigate this intricate landscape, the fusion of robust AI frameworks, ethical considerations, and continuous innovation becomes paramount. The proverbial road ahead is long and winding. Still, with collaboration, innovation, and a commitment to excellence, we believe a future where technology seamlessly aligns with safety and inclusivity is within reach.  

Drawing from our hands-on experience with deep learning libraries like PyTorch, which are instrumental in powering autonomous vehicles, we recognize this domain's vast potential and challenges. As we forge ahead, expanding our AI practice with exciting projects and groundbreaking initiatives (like our AI safety startup, BigFilter.ai), our commitment remains unwavering. We are dedicated to advancing the frontiers of AI, machine learning, and software engineering, striving to sculpt a safer and more efficient digital future.  

Get in contact [here](https://www.janeasystems.com/contact) to find out more about our work.

large_Robotaxi Blog Cover Taxi.png

medium_Robotaxi Blog Cover Taxi.png

small_Robotaxi Blog Cover Taxi.png

thumbnail_Robotaxi Blog Cover Taxi.png

Robotaxi Blog Cover Taxi.png

The Winding Road to Autonomous Taxis: A Journey of Progress and Perils 

Working at Janea

The notion of a "10x engineer" who boasts 10x more productivity than the average continues to be a hot topic in software engineering. Some say the term is like a carrot on a stick, a way to make engineers work harder. Some say the 10x stands for being ten times harder to work with, and others swear by these unicorns that effortlessly devise the most efficient solutions where their peers couldn't compute.  

Within every profession, there are varying skill levels, but what truly constitutes this elite talent tier? With over two decades of working with some of the world's most gifted problem solvers, we've developed a formula for consistently recruiting, retaining, and challenging these unicorns. Read on to learn what sets 10xers apart, how they create outsized impact, and ways to build an environment to help them thrive. 

## Demystifying the Mythos

The concept of 10x engineers originated from a 1968 study that [showed vast performance differences between engineers](https://dl.acm.org/doi/10.1145/362851.362858)  debugging code.  

![Table 3 range 10X engineer blog.png](https://cloud-cube-us2.s3.amazonaws.com/nqnr0sjjo9vs/public/Table_3_range_10_X_engineer_blog_d90aab6560.png)

![](https://www.janeasystems.com/wp-content/uploads/2023/08/image.png)

While the study has its flaws, for example, it combines programmers working in high and low-level languages (bear in mind it was published the year after the floppy disk was invented), a kernel of truth remains: significant gaps in output and quality exist between elite and average talent. 

True 10xers are rare, and their edge comes from a distinct interplay between nature and nurture. However, despite great software engineering requiring close collaboration, not heroes, developers in the top decile deliver disproportionate value. Here's how: 

## Laser Focus on Customer Outcomes

Elite developers maintain an unwavering focus on solutions that deliver maximum real-world value instead of chasing technically interesting dead ends. They draw from deep technical skills to simplify even the most challenging problems into consumable products and services, leading to exponential business impact. For example, our engineers drove innovation in Node.js file writing, making tools like node-tar run up to 50% faster, significantly speeding up software installations and updates for our clients, and ensuring a smoother user experience. It's this kind of customer-centric problem-solving that epitomizes the 10x mindset. 

## Voracious Learners

10x engineers remain lifelong students, rapidly assimilating new languages, tools, and techniques. They intrinsically enjoy the journey of continuous skill expansion, and they help others do the same. Our team pursues side projects, hackathons, programming competitions and online courses to stay sharp. Željko, our Senior Software Engineer, established a non-profit organization, [empowering children aged 8-14 to design, build, and program their very own robots](https://www.linkedin.com/posts/c-h-a-o-s-josipovac_chaosjosipovac-robotics-stemeducation-activity-7074419955751878657-pIr0/?utm_source=share&utm_medium=member_desktop). We nourish this appetite for learning through regular knowledge-sharing sessions and dedicated time for self-driven education. This mindset enables us to continually deliver on key initiatives that affect millions of developers (like PyTorch, React Native, and Node.js) and services that affect billions worldwide (such as Expedia, Bing, and the Italian Railway Network). 

## Masters of Collaboration

Lone coding cowboys may seem impressive, but they can also be counterproductive. As software scales in complexity, collaboration becomes critical. Hiring competent problem solvers is only one half of the story. While technical acumen is essential, the human elements of teamwork, such as effective communication, mentorship, accountability, and a commitment to collective goals, become equally pivotal. True 10xers recognize that achieving overarching project objectives takes precedence over individual accolades. 

## Finding, Hiring and Keeping 10x Engineers

With such massive potential upside, how do you build a team of 10xers? Unlike many companies that are marching engineers back into the office, we've been remote-native from day one, enabling us to connect with exceptional software engineers from all over the world. Being globally distributed provides significant advantages - access to the top 1% unconstrained by geography, diversity of perspectives, flexibility, and results-focused culture. 

We utilize a rigorous recruiting process honed over nearly two decades, assessing problem-solving skills, technical knowledge, soft skills, and culture fit. We prize engineers who take initiative and elevate those around them. 

Once hired, we invest heavily in professional growth through mentorship, learning resources, and opportunities to work on cutting-edge challenges. Our engineers gain exposure to diverse codebases and industries, multiplying their capabilities, and we regularly promote from within to retain our stars. 

## Conclusion

In the ever-evolving realm of software engineering, the allure of the "10x engineer" continues to captivate and challenge our perceptions of productivity and talent. While the term may originate from a study with its own imperfections, its essence captures a truth in the industry: there are individuals who, through a blend of innate talent, dedication to growth, and a collaborative spirit, drive exceptional value. But identifying these talents is only half the journey; nurturing and fostering their growth in an inclusive, global, and adaptive environment is key. As software engineering continues to evolve, so too will our understanding of what defines excellence in this field, but the principles of continuous learning, customer-centricity, and collaboration will always remain at its core. 

If you're a driven developer looking to reach your 10x potential, take a look at our latest job posts [here](https://www.janeasystems.com/current-openings/). Or, if you're looking to leverage our deep technical expertise to drive your next software engineering feat, contact us [here](https://www.janeasystems.com/#lets-talk).

large_10X Engineer blog.png

medium_10X Engineer blog.png

small_10X Engineer blog.png

thumbnail_10X Engineer blog.png

10X Engineer blog.png

The Myth and Reality of the 10x Engineer

In an exciting partnership between Microsoft and Janea Systems, a whole host of iOS and Android React Native modules have been ported to react-native-windows. Adding these modules to the react-native-windows environment has solved some major technical challenges for Microsoft, its customers, and the open source community.  

It was essential that these customers could port their iOS and Android mobile applications over to a Windows environment. With these modules now available, the development teams can accelerate bringing their features and functions into a desktop setting and delight their customers across multiple platforms. 

The expertise and deep development experience of the Janea Systems team proved essential in overcoming some critical roadblocks and hurdles in producing an impressive array of react-native-windows modules.   
 

For more information on the react-native-windows ecosystem, new features, and developments, including Janea System's partnership, see the following blogspot: [Gallery App, TurboModules, and more community modules · React Native for Windows + macOS (microsoft.github.io)](https://microsoft.github.io/react-native-windows/blog/2021/03/16/64updates#%F0%9F%A4%9D-janea-systems) 

## What are modules and why are they important? 

Modules are an essential part of the cross-platform development process for building applications and features in React Native, extending the functionality, and making use of native APIs and function calls. 

The modules that were most important for Microsoft and its customers to be ported to react-native-windows are listed below: 

<table><tbody><tr><td>React-native-device-info &nbsp;</td><td>React-native-device-info gets hardware and OS-specific information. This function is crucial for optimizing app performance and enabling developers to build Windows apps that adapt to a diverse range of devices.&nbsp;</td></tr><tr><td>React-native-sensitive-info&nbsp;</td><td>React-native-sensitive-info module can get and set sensitive data. This feature allows developers to effortlessly maintain data integrity and user privacy on Windows apps, ensuring consistent and secure handling of sensitive information.&nbsp;</td></tr><tr><td>React-native-sketch-canvas &nbsp;</td><td>React-native-sketch-canvas module allows users to draw and sketch on a canvas or image. It has unblocked Microsoft clients in education by enabling pupils and teachers to incorporate digital drawing into their learning environments easily.&nbsp;</td></tr><tr><td>React-native-config &nbsp;</td><td>React-native-config module allows the addition of build-time configuration values that can be read at run time. It allows developers to manage environment-specific configurations effectively, improving app performance and consistency across various runtime environments.&nbsp;</td></tr><tr><td>React-native-permissions&nbsp;&nbsp;</td><td>React-native-permissions is used to read and request system permissions. It is vital for a streamlined user experience as it provides developers with an efficient way to request and handle system permissions, ensuring a seamless and secure app experience for end-users.&nbsp;</td></tr><tr><td>React-native-print&nbsp;&nbsp;</td><td>React-native-print is used to print PDFs. It offers developers the tools needed to simplify document handling for users by integrating printing functionality directly into their applications.&nbsp;</td></tr><tr><td>React-native-pdf&nbsp;&nbsp;</td><td>React-native-pdf is used to render PDFs. This proves critical for content-heavy applications as it allows developers to provide users with a seamless, efficient document-viewing experience.&nbsp;</td></tr><tr><td>React-native-tts&nbsp;&nbsp;</td><td>React-native-tts allows Text to Speech using system voices. It enables developers to enhance app interactivity and accessibility significantly, creating more engaging user experiences with text-to-speech functionalities.&nbsp;</td></tr><tr><td>React-native-auth0 &nbsp;</td><td>React-native-auth0 allows single sign-on to OAuth services. It provides a streamlined authentication experience for users, enabling developers to offer secure single sign-on functionalities within their apps.&nbsp;</td></tr><tr><td>React-native-gesture-handler &nbsp;</td><td>React-native-gesture-handler allows native gesture recognition on touch devices. This facilitates developers in creating more immersive and intuitive app experiences by implementing native gesture recognition in touch-enabled applications.&nbsp;</td></tr><tr><td>React-native-linear-gradient &nbsp;</td><td>React-native-linear-gradient enables developers to craft visually appealing interfaces by incorporating native linear gradients into app designs.&nbsp;</td></tr><tr><td>React-native-track-player&nbsp;&nbsp;</td><td>React-native-track-player adds media player functionality. This empowers developers to create rich multimedia applications, providing users with an integrated, high-quality media player experience.&nbsp;</td></tr><tr><td>React-native-splash-screen &nbsp;</td><td>React-native-splash-screen extends the application splash screen until dismissed. It enhances user experience during app load times by allowing developers to present visually pleasing and custom load sequences.&nbsp;</td></tr><tr><td>React-native-art&nbsp;&nbsp;</td><td>React-native-art is a vector graphics library. It inspires creativity by offering developers a toolset for integrating vector graphics into their applications, enriching the visual appeal.&nbsp;</td></tr><tr><td>React-native-progress-view &nbsp;</td><td>React-native-progress-view shows a progress bar. It is an effective tool for providing user feedback, enabling developers to display progress indicators, thus improving user experience.&nbsp;</td></tr><tr><td>React-native-screens &nbsp;</td><td>React-native-screens offers native screen handling for react-navigation. It optimizes app navigation performance, offering developers a resource-efficient tool for managing multiple screens in react-navigation.&nbsp;</td></tr></tbody></table>

## Overview of How to Build a React Native Windows Module 

This particular process of porting existing iOS and Android modules over to Windows involved a steady, incremental process, which can be summarized as follows: 

* Initial analysis - understand what the module does, its dependencies, requirements, and how it's implemented on Android and iOS. 
* Porting the module to Windows - use appropriate UWP APIs to get the same features on Windows, using good practices. Examine the code, compare the JavaScript to the native code, and examine how many classes there are. 
* Testing the module - incrementally test its features as they are developed. 
* Update documentation - add instructions on how to use the module on Windows. 
* Windows example - update the example project to also run on Windows / create a Windows example project. 
* Add tests - add automated testing / CI to test the Windows version of the module. 

## Key learnings/takeaways and what to do when developing modules in this way 

This was an excellent endeavor for both Microsoft and the Janea Systems development teams, with a total of sixteen essential React native modules being ported to Windows. From performance to accessibility, porting these modules brought React Native for Windows up to speed with other OSs. This unblocked Microsoft customers and the open source community and ensured devs could create a diverse range of applications. 

As mentioned in the process overview, it's a case of examining the existing iOS and Android react native modules and gauging the complexities of developing a react-native-windows version. It depends on the complexity of the module, how much of the code is native/C++/Java versus how much of it is in JavaScript. For example, when porting modules from mobile to desktop environments, you must be cognizant of the differences because there are cases where dependencies aren't present on desktop. On top of this, there are the added complexities of understanding the existing modules in iOS and Android, which use different languages, e.g., Swift, Objective-C, Java, etc.  

## Conclusion 

Here at Janea, we understand the importance of cross-platform development, and that's why interoperability is at the heart of many of the ground breaking projects we work on. Whether you're a developer or not, this project affects millions of Windows users worldwide. We're incredibly proud of unblocking Microsoft customers while allowing the open source community to build with, and on top of, these modules to create outstanding React Native Windows applications without compromise. 

Contact us to learn how Janea can help you with your software engineering needs [here](https://www.janeasystems.com/#lets-talk).

large_React Native Blog.png

medium_React Native Blog.png

small_React Native Blog.png

thumbnail_React Native Blog.png

React Native Blog.png

Janea Systems Helps Unblock Key Microsoft Customers Utilizing React Native for Windows  

Industry Updates

Amidst the complex ecosystem of technology and consulting, confident leaders stand out for their foresight and innovation. Holding the reigns at Janea Systems and the government-grade data store, Memurai, Mike is that beacon of leadership. Let’s dive deeper into Mike’s journey and what makes him the dynamic leader of Janea Systems. 

## A Leader Focused on Team Empowerment

As Chief Executive Officer, Mike’s role extends beyond just management; he embodies the very ethos of Janea Systems, ensuring that every stride the company takes is in sync with the evolving tech landscape. A cornerstone of his leadership philosophy? In Mike’s own words: “As leaders, our most important job is creating an environment where our team can thrive. A team that feels valued, empowered, autonomous, and connected will naturally excel, delivering value for our clients and propelling the company forward.”  

## A Tactical Trailblazer

Across two transformative decades, Mike has channeled his expertise into tech consulting services, software solutions, and the meticulous cultivation of high-performance teams. 

Mike’s trajectory at Janea Systems is symbolic of his dedication and strategic prowess. Starting as the Senior Vice President of Operations, Mike quickly ascended through the ranks, first to COO and now CEO in just over two years. His commitment to excellence and progressive leadership has seen Janea Systems surge to unprecedented heights during his tenure, growing more than 80% annually for the last two years.

## Legacy of Strategic Insight

A series of influential roles underscore Mike’s legacy of leadership. Mike’s initial foray into the consulting world began at Deloitte, where he cultivated his technology, client management, and leadership expertise. His career trajectory later carried him through a range of pivotal roles at multiple consulting firms, further honing his skills before transitioning into the software sector at Oco. During this time, he built the professional services function from the ground up and captured the attention of the place where he first started, Deloitte. The circle was completed when Deloitte successfully acquired Oco, marking Mike’s return, but this time leading the Managed Analytics services team. His dual stints at Deloitte—first as a young consultant and later via acquisition — laid the groundwork for his subsequent leadership roles, shaping a career marked by innovative thinking and strategic execution.   

Mike later joined Altisource to spearhead professional services for their newly formed Labs unit. He then took a more significant role leading business operations for the technology division, comprised of more than 1000 team members across the globe. In this role, his operational understanding came to the forefront as he streamlined processes, introduced innovative business models, and revamped the division’s financial management approach, resulting in impressive savings and revenue gains. Each chapter of Mike’s career builds upon the last, encapsulating his steadfast commitment to raising the bar in tech leadership. 

## A Comprehensive Knowledge Base

Rensselaer Polytechnic Institute’s rigorous B.S. program in Biomedical Engineering equipped Mike with an education that intersects technology with biomedical insights. This academic alchemy arms Mike with a multidimensional view, allowing him to approach tech problems with a blend of precision and creativity. 

## Outside of Work

Beyond his professional commitments, Mike treasures his personal life. Originally from Connecticut, Mike has set down roots in Natick, near Boston. Away from the tech world’s hustle and bustle, he cherishes moments with his wife, Kadie, and their three young children. 

## The Future of Janea 

Mike’s 20+ year career sits at the intersection of leadership, operations, and technology. His analytical approach, honed through leading teams across sectors such as professional services, product, and software engineering, brings a results-oriented perspective to Janea Systems. As CEO, Mike has focused intently on new market expansion, recruiting top-tier talent, and maintaining a rigorous focus on client delivery. With his strategic vision rooted in operational excellence, Janea Systems is charting an ambitious course to redefine software engineering consulting’s future boundaries.

large_Mike Decerbo Leadership Spotlight.png

medium_Mike Decerbo Leadership Spotlight.png

small_Mike Decerbo Leadership Spotlight.png

thumbnail_Mike Decerbo Leadership Spotlight.png

Mike Decerbo Leadership Spotlight.png

Leadership Spotlight: Mike DeCerbo – Cultivating Excellence at Janea Systems

A large enterprise came to us with the objective of writing an iOS SDK for Swift and Objective-C developers. Converting Objective-C to Swift and vice-versa can be a grueling task, but not for our expert iOS team.

Our Senior iOS Developer, Denis Bogomolov, takes us through the technical challenges of creating interoperable frameworks for Swift and ObjC - highlighting some of the complex problems we overcame. To make the most of this post, you will need an understanding of;

* Swift and/or Objective C programming languages.
* Xcode IDE
* Data types such as integers, strings, arrays and objects.
* Common programming constructs e.g. functions, classes and methods.
* Protocols and their role in defining interface contracts between components of an application.

# Swift VS Objective-C

Released in 2014, Apple claims that Swift is 2.6 times faster than Objective-C while being easier and safer to develop with. On the other hand, Objective C is nearly 40 years old and Swift applications use up to 70% less code. This begs the question; why would we need to do anything with ObjC these days? Well, despite [Apple’s intention to replace Objective-C](https://www.swift.org/about/), there's still a substantial amount of developers keeping the language alive and tons of core iOS and MacOS programs written in Objective-C (that won't be going anywhere anytime soon). In addition, Objective-C boasts excellent interoperability with C and C++. 

# Writing an SDK in Swift, ObjC, or a Mix of Both: Client Requirements and Our Approach

On the face of things, our client's objectives were quite straightforward:

1\. Write an SDK that can be consumed by Objective-C and Swift apps

2\. Make the public API feel native to Objective-C and Swift developers

The client trusted our expertise in coming up with the best course of action. We know it's becoming harder to find skilled developers that are proficient in ObjC. To avoid making it difficult for our client to support the project in the future, we consciously decided to write as little ObjC as possible while adhering to their objectives. Although writing a project in a mix of Objective-C and Swift is the worst of both worlds, because it limits the full utilization of Swift's advanced features, the public API wasn't too complex. This meant we could write 95% in Swift with edge cases written in ObjC.

## Special Mention to Xcode’s Generated Interface

Before we go into details, we'd like to say a huge "thank you" to this square-chain guy and his friend, Generated Interface.

![](https://www.janeasystems.com/wp-content/uploads/2023/04/Generated-Interface-416x1024.jpg)

Basically, Xcode would generate Swift interfaces from  ObjC files, and an ObjC header file from Swift files, so you can look at how one language imports declarations from another. This helped us understand how different attributes affect public APIs.

# How to Import ObjC into Swift and Swift into ObjC,

Let's start with the basics:

## Importing ObjC into Swift

There are no bridging headers when dealing with frameworks. Instead, in the umbrella header, you need to import all of the ObjC headers you want to expose to Swift. Once this is done, the content of these headers is automatically available in any Swift file. No imports needed.

```plaintext
//! Project version number for TotallyUnique.
FOUNDATION_EXPORT double TotallyUniqueVersionNumber;

//! Project version string for TotallyUnique.
FOUNDATION_EXPORT const unsigned char TotallyUniqueVersionString[];

// In this header, you should import all the public headers of your framework using statements like #import <TotallyUnique/PublicHeader.h>
#import <TotallyUnique/TUQInterfaceStyle.h>
#import <TotallyUnique/TUQOptionKey.h>
```

## Importing Swift into ObjC

In ObjC implementation \`.m\` files, you can import the Xcode-generated \`-Swift.h\` header to use your Swift code.

```plaintext
#import <TotallyUnique/TotallyUnique-Swift.h>
```

You may have already noticed our first big issue. To expose an ObjC declaration to Swift or Swift declaration to ObjC, you need to mark this declaration as public, in other words, make it part of the public API.

## Macros

When bridging Objective-C and Swift, there are a number of macros to aid interoperability. A few of these include:

* NS\_ASSUME\_NONNULL\_BEGIN and NS\_ASSUME\_NONNULL\_END
* NS\_SWIFT\_NAME
* NS\_REFINED\_FOR\_SWIFT
* NS\_TYPED\_ENUM
* NS\_ENUM and NS\_OPTIONS
* NS\_DESIGNATED\_INITIALIZER

The usage of macros would depend on the specific challenges of your project. Here we explain how we used some of them while writing this SDK.

### NS\_TYPED\_ENUM

Personally, RawRepresentable enums are one of my most used features in Swift, but they are incompatible with ObjC, with the exception of integer-based enums. To get around this you can employ the aforementioned \`NS\_TYPED\_ENUM\`  macro. You declare a new typedef for your constants, then add the macro, and you can even customize the type name in Swift using 'NS\_SWIFT\_NAME'.

```plaintext
//! Project version number for TotallyUnique.
FOUNDATION_EXPORT double TotallyUniqueVersionNumber;

//! Project version string for TotallyUnique.
FOUNDATION_EXPORT const unsigned char TotallyUniqueVersionString[];

// In this header, you should import all the public headers of your framework using statements like #import <TotallyUnique/PublicHeader.h>
#import <TotallyUnique/TUQInterfaceStyle.h>
#import <TotallyUnique/TUQOptionKey.h>typedef NSString * TUQInterfaceStyle NS_TYPED_ENUM NS_SWIFT_NAME(InterfaceStyle);
/// Interface style based on user preferences.
FOUNDATION_EXPORT TUQInterfaceStyle const TUQInterfaceStyleAuto;
/// Dark interface.
FOUNDATION_EXPORT TUQInterfaceStyle const TUQInterfaceStyleDark;
/// Light interface.
FOUNDATION_EXPORT TUQInterfaceStyle const TUQInterfaceStyleLight;
```

It will produce this for you. It's close to what I would write myself.

```plaintext
public struct InterfaceStyle : Hashable, Equatable, RawRepresentable {
    public init(rawValue: String)
}
extension InterfaceStyle {
    /// Interface style based on user preferences.
    public static let auto: InterfaceStyle
    /// Dark interface.
    public static let dark: InterfaceStyle
    /// Light interface.
    public static let light: InterfaceStyle
}
```

In the first block of code, you can see we have created a new type representing different interface styles called "TUQInterfaceStyle". We then used the NS\_TYPED\_ENUM macro which generates a struct that uses the new type and makes it conform to Hashable, Equatable, and RawRepresentable protocols. This alleviates the problem of incompatible enums in Objective-C.

### NS\_SWIFT\_NAME

We've just seen this in the previous point. At a glance, this macro simply overrides a type name that can be used in Swift, but it can do more than that. For example, it can nest one type within another and transform C-style functions into class functions or properties.

```plaintext
typedef NSString * TUQInterfaceStyle NS_TYPED_ENUM NS_SWIFT_NAME(InterfaceStyle);
FOUNDATION_EXPORT BOOL TUQInterfaceStyleIsSafeForEyes(TUQInterfaceStyle style)
    NS_SWIFT_NAME(getter:InterfaceStyle.isSafeForEyes(self:));
FOUNDATION_EXPORT TUQInterfaceStyle TUQInterfaceStyleFromInt(NSInteger style)
    NS_SWIFT_NAME(InterfaceStyle.init(from:));
```

---

```plaintext
public struct InterfaceStyle : Hashable, Equatable, RawRepresentable {
    public init(rawValue: String)
}
extension InterfaceStyle {
    public var isSafeForEyes: Bool { get }
    public /*not inherited*/ init(from style: Int)
}
```

Be careful! It's easy to get into a chicken-egg situation:

```plaintext
@class Option;
typedef NSString * TUQOptionKey NS_TYPED_ENUM 
NS_SWIFT_NAME(Option.Key);
FOUNDATION_EXPORT TUQOptionKey const TUQOptionKeyScale;
```

```plaintext
@objc(TUQOption)
public class Option: NSObject {
    @objc
    public var key: Option.Key
    @objc(initWithKey:)
    public init(key: Option.Key) {
        self.key = key
        super.init()
    }
}
```

This code would compile, and even produce expected preview headers, but declarations would not be available when you try to consume the framework.

**Fun Fact:** The NS prefix is a nod to NeXTSTEP - an operating system developed by NeXT in the late 1980s. NeXT was founded by Steve Jobs after leaving Apple, and the company developed innovative hardware and software solutions. NeXTSTEP had a significant impact on computing history, including influencing Objective-C and Cocoa frameworks, and serving as the platform for the creation of the first web browser by Tim Berners-Lee. Apple acquired NeXT in 1996 and incorporated much of NeXTSTEP into Mac OS X, including existing class names. Take a look at Steve Jobs unveiling the $6500, 17" display NeXT computer in 1988. [Steve Jobs Unveils the NeXT Computer - October 12, 1988](https://www.youtube.com/watch?v=92NNyd3m79I&ab_channel=TheReDiscoveredFuture)

### @objc

You may have noticed one more relevant attribute. 

```plaintext
@objc(TUQOption)
public class Option: NSObject {
    @objc
    public var key: Option.Key
    @objc(initSomethingSomethingKey:)
    public init(key: Option.Key) {
        self.key = key
        super.init()
    }
}
```

```plaintext
SWIFT_CLASS_NAMED("Option")
@interface TUQOption : NSObject
@property (nonatomic) TUQOptionKey _Nonnull key;
- (nonnull instancetype)initSomethingSomethingKey:(TUQOptionKey _Nonnull)key ObjC_DESIGNATED_INITIALIZER;
- (nonnull instancetype)init SWIFT_UNAVAILABLE;
+ (nonnull instancetype)new SWIFT_UNAVAILABLE_MSG("-init is unavailable");
@end
 
```

According to the documentation, the generated \`-Swift.h\` header should contain all declarations marked as \`public\` or \`open\`. We found this behavior to be inconsistent, so we agreed to explicitly mark all declarations that should be available in ObjC with \`@objc\`. Additionally, you can provide a new ObjC-name in parenthesis similar to \`NS\_SWIFT\_NAME\`. 

You can add an \`@objc\` attribute to an internal declaration. This way, it would not be exposed in the public header but will be available in ObjC runtime for magic like: \`valueForKey\`, \`selectorWithName\` etc. Beware! Adding @objc to internal declarations can have performance and binary implications so it's important to understand the reasons why you would do this. Exposing declarations to Objective-C increases the size of your binary, potentially leading to other issues such as; longer download and installation times for users, increased memory/resource consumption on a user's device and more potential for errors and conflicts as larger binaries can increase the risk of bugs. This is why, in general, you should only mark declarations with @objc if you know that they will be used from Objective-C code, or if you want to ensure that they can be accessed from other Swift modules that rely on Objective-C APIs.

These 3 macros/attributes covered almost all of our needs. Ultimately, the examples above made it much easier for Swift and Objective-C developers to work with interface styles such as dark mode and light mode.

# Technical problems: Default values in functions, Mutability Mappings and more.

Let's take a look at how we overcame some of the trickier problems we faced:

## Default values in functions

Unlike Swift, there isn't a direct way of setting default parameter values in Objective-C. In Swift, you can declare a default value in the function definition. This means that if the caller doesn’t provide a value, the default value is used automatically. To achieve this in Objective-C, we need to write such functions twice: once with the default value set inside the function code and once without the default value. 

```plaintext
@objc
public func withValue(_ number: Int = 9) { }
```

```plaintext
- (void)withValue:(NSInteger)number;
```

This is also an example of why writing in Swift uses less code than Objective-C.

## Passing primitives around

It's common for ObjC to pass an array of primitives or C-structs as a pointer to array and number of items. While in Swift you would expect to pass just an array of primitives, when translated into ObjC the compiler automatically wraps such primitives in \`NSValue\`. As a result, we need to declare two functions: one Swift style and one ObjC style.

```plaintext
@objc
public func withValue(_ locations: [CLLocationCoordinate2D]) { }
@objc
public func withValue(_ locations: UnsafePointer<CLLocationCoordinate2D>, count: Int) { }
```

```plaintext
- (void)withValue:(NSArray<NSValue *> * _Nonnull)locations;
- (void)withValue:(CLLocationCoordinate2D const * _Nonnull)locations 
count:(NSInteger)count;
```

In ObjC code you could use \`NS\_REFINED\_FOR\_SWIFT\` to provide a different function or \`NS\_SWIFT\_UNAVAILABLE\` to hide one of them.

Swift has no such tools. 

## Mutability mappings

Let's say you are writing a function that takes \`URLRequest\`, modifies it and returns it.

In ObjC you would just pass in \`NSMutableURLRequest\` but in Swift, \`URLRequest\` is a struct. 

```plaintext
@obj
cprotocol URLRequestTransformer: NSObjectProtocol {
    func modify(_ request: NSMutableURLRequest)
    func modify(_ request: URLRequest) -> URLRequest
    func modify(_ request: inout URLRequest)
}
```

The first variant is foreign in Swift.

The second is foreign in ObjC.

The third cannot be represented in ObjC at all.

# Building Cross-Language Swift & Objective-C SDKs

In all our years of iOS development, we've found ourselves in many precarious situations when there's a correct, intended, Apple way to do something, and then there is what you need to do.

This is a case in point. Apple does a lot to help you use old ObjC code in Swift, but doing the inverse poses a myriad of issues.

Was it worth it? Definitely! We're not scared of tackling the hairier software challenges when it comes to making our clients' lives easier. These examples are just a smidgen of the work that went into creating the SDK. 

This project expands the market of our client's enterprise software to over a billion iOS users. Leveraging our team's intricate understanding of the two main languages that power iOS, the software now has functional parity across Web, Android, and iOS SDKs. We're incredibly proud of our work on this project because it opens access to a more diverse and skilled developer community while future-proofing our client's software.

---

Denis Bogomolov (project lead) is a Senior iOS developer at Janea Systems. He believes it is important not just to deliver a solution, but to deliver the correct solution with clear justification. Denis has over a decade of experience in software development, delivering projects for companies such as Microsoft, MetLife, Showmax, Nedbank, and Vodafone. Find him on [Github](https://github.com/ManWithBear) and [Linkedin](https://www.linkedin.com/in/manwithbear/?originalSubdomain=cz).

Learn more about how Janea Systems solves some of the most complex technological software engineering and product development challenges. Speak to an expert [here](https://www.janeasystems.com/#lets-talk).

large_Denis-Bogomalov-ios-Blog-split-files.png

medium_Denis-Bogomalov-ios-Blog-split-files.png

small_Denis-Bogomalov-ios-Blog-split-files.png

thumbnail_Denis-Bogomalov-ios-Blog-split-files.png

Denis-Bogomalov-ios-Blog-split-files.png

Building an SDK with Swift & Objective-C: A Developer's Guide

As the sci-fi writer Isaac Asimov once said, "today's science fiction is tomorrow's science fact," and with the ongoing AI arms race, this quote rings truer than ever. Over the last few weeks, we've seen pirated and leaked large language models being tweaked to create personal AIs, [Boston Dynamics robodogs being hooked up with ChatGPT](https://www.youtube.com/watch?v=XyCKe3rrYik&ab_channel=STrucBot), and groundbreaking developments in generative AI amidst a backdrop of growing concerns and regulatory efforts. Let's take a closer look at these developments and their implications for the future of AI.

## **Software Engineering**

As expected, we're seeing continuous improvements within the Enterprise AI software engineering landscape.

Amazon announced new tools for building generative AI applications with the launch of [Amazon Bedrock and Amazon Titan models](https://aws.amazon.com/blogs/machine-learning/announcing-new-tools-for-building-with-generative-ai-on-aws), making it easier than ever for developers to access and integrate powerful Foundation Models from AI21 Labs, Anthropic, Stability AI, and Amazon.

Google also claims that its [AI supercomputer is faster and more environmentally friendly than Nvidia's A100 chip](https://www.reuters.com/technology/google-says-its-ai-supercomputer-is-faster-greener-than-nvidia-2023-04-05/?utm_source=www.aiwithvibes.com&utm_medium=newsletter&utm_campaign=germany-may-ban-chatgpt-biden-talks-ai), highlighting the importance of addressing the environmental impact of running these massive models.

## **Enterprise AI**

Google's Bard AI faced criticism for underperforming compared to GPT. The company's CEO [acknowledged the shortcomings](https://www.theverge.com/2023/3/31/23664426/google-bard-ai-chatbot-upgrades-coming-soon-sundar-pichai), comparing Bard to a "souped-up Civic … in a race with more powerful cars" and committed to upgrading it with more capable PaLM models.

Elon Musk [reportedly bought thousands of GPUs](https://www.engadget.com/elon-musk-reportedly-bought-thousands-of-gpus-for-a-twitter-ai-project-214535382.html) for a Twitter AI project and announced plans to launch [a ChatGPT competitor](https://www.ft.com/content/2a96995b-c799-4281-8b60-b235e84aefe4),

Research startup Anthropic [aims to raise as much as $5 billion over the next two years](https://techcrunch.com/2023/04/06/anthropics-5b-4-year-plan-to-take-on-openai/) to compete with OpenAI and enter over a dozen major industries, signaling an ambitious plan to establish a strong market presence.

Bloomberg introduced [BloombergGPT](https://www.bloomberg.com/company/press/bloomberggpt-50-billion-parameter-llm-tuned-finance), a large-scale generative AI model specifically trained on financial data, which outperforms similarly-sized open models on financial NLP tasks without sacrificing performance on general LLM benchmarks.

Meta launched the [Segment Anything project](https://ai.facebook.com/blog/segment-anything-foundation-model-image-segmentation) to democratize image segmentation, releasing a new model and the largest-ever segmentation dataset, SA-1B, fostering research and broad applications for foundation models in computer vision. Meta also plans to use [generative AI for ad creation](https://techcrunch.com/2023/04/05/meta-wants-to-use-generative-ai-to-create-ads), with its CTO, Andrew Bosworth, expecting commercialization of the tech this year.

Alibaba and Huawei are set to [debut generative AI chatbots](https://www.theregister.com/2023/04/05/alibaba_huawei_chatgpt_clones/) to cater to local demand in China following the release of OpenAI's ChatGPT.

These developments highlight the global enthusiasm for AI advancements and the need for localized solutions geographically and within different industries.

## **LLM's & Privacy**

In light of the recent privacy concerns and ethical dilemmas, some of which were highlighted in [our March roundup](https://www.janeasystems.com/blog/march-of-the-machines-ai-roundup/), companies and governments are becoming increasingly vigilant about AI's implications on privacy, especially following Italy's ban on ChatGPT.

At the end of March, Italy's data-protection regulator banned ChatGPT in the country, citing privacy concerns and a lack of age verification giving Open AI 20 days to respond. Meanwhile, other countries and regulatory bodies were considering doing the same. With the company on the back foot, OpenAI swiftly implemented data controls [allowing users to opt out of their chats being used to train models](https://openai.com/blog/new-ways-to-manage-your-data-in-chatgpt) and stop conversations from being saved. It also added functionality to export chats, a pop-up to satisfy the regulator's age verifications where users can click a button stating "I meet OpenAI's age requirements," and clearer links to their privacy policy when signing up to the platform. These swiftly implemented features have been enough to get them back up and running in Italy.

OpenAI's also introduced a [Bug Bounty Program](https://openai.com/blog/bug-bounty-program) to address potential vulnerabilities and improve the safety of their technology, no doubt a response to the March data breach, which allowed some users to see others' chat history and payment details during a nine-hour window. In addition to all of this, they posted a blog entitled "[Our Approach to AI Safety](https://openai.com/blog/our-approach-to-ai-safety)."

  
For now, OpenAI seems to be out of hot water, but there will likely be more regulatory challenges ahead that will affect OpenAI and other AI companies.

## **AI Regulation**

The United Kingdom, European Union, United States, and China have made strides in AI regulation, with each region taking distinct approaches. The UK government released a [white paper](https://assets.publishing.service.gov.uk/government/uploads/system/uploads/attachment_data/file/1146542/a_pro-innovation_approach_to_AI_regulation.pdf) outlining a principles-based, adaptive approach to AI regulation. This contrasts with the more prescriptive [EU AI Act](https://artificialintelligenceact.eu/the-act/) and aims to ensure the UK remains an innovation-friendly jurisdiction for AI developers. However, the UK's approach may leave gaps in regulation, unlike the more holistic approach of the EU. Conversely, the EU has been urged to expand its AI Act to regulate general-purpose AI, as the legislation is currently going through the legislative process in the European Parliament. 

China has [announced measures](https://www.cnbc.com/2023/04/11/china-releases-rules-for-generative-ai-like-chatgpt-after-alibaba-launch.html) to monitor generative AI products closely, requiring companies planning to launch such products to undergo security assessments by the Cyberspace Administration of China (CAC).

In the United States, Senate Majority Leader [Chuck Schumer proposed a framework for AI regulation](https://www.axios.com/newsletters/axios-am-5a9feedd-5411-4bc8-a5ee-94f9b5cb6e0a.html), which has not yet been drafted into legislation. His proposal would require companies to allow independent experts to review and test AI technologies before public release or updates and grant users access to findings. Schumer cited China's recent release of its own AI regulations as a wake-up call, emphasizing the need for the US to lead in shaping the rules governing AI.

Canada is considering the Artificial Intelligence and Data Act (AIDA) as part of [Bill C-27](https://www.parl.ca/legisinfo/en/bill/44-1/c-27). Following the release of a [companion policy to AIDA](https://ised-isde.canada.ca/site/innovation-better-canada/en/artificial-intelligence-and-data-act-aida-companion-document) that sets a two-year strategy for regulation development, critics argue that AIDA gives too much power to the government, such as fines hefty fines of up to $25m or 5% of gross global revenue, especially with the specifics being left to unpublished regulations. Despite this, the bill is closer to becoming law as legislators voted to send it to the Standing Committee on April 24th.

Overall, AI regulation is becoming a global focus, with different countries taking varied approaches to balance innovation, safety, and ethical concerns. This is great for consumers of Enterprise AI, but many of the regulations above don't consider individuals. With AI becoming more democratized by the day, with leaked and open source AI available to anyone, there's another world of complexity to consider.

## **Piracy, Personalisation & Open Source**

Remember when 'piracy' meant Limewire, a slow dial-up connection, and the delicate art of burning DVDs? Today, we've cast off into uncharted territories, with AI systems as the new bounty.

On February 24th, [Meta launched an open source LLM](https://ai.facebook.com/blog/large-language-model-llama-meta-ai/) with no instruction or conversation tuning called LLaMA. The LLaMA model was intended to only be available to researchers. It was leaked within a week and is now downloadable via torrents, despite Meta's attempts to quell distribution with DCMA requests. Since then, we've seen waves of innovation and experimentation from individuals and research institutions alike.

On March 13th, [Stanford released Alpaca](https://crfm.stanford.edu/2023/03/13/alpaca.html), which added instruction tuning to LLaMA. This allowed anyone to fine-tune the model on a beefy laptop, effectively kicking off a race to develop low-budget fine-tuning projects. By March 18th, [LLaMa could be run effectively on a MacBook CPU](https://github.com/ggerganov/llama.cpp). 10 days later, on the 28th, a [LLaMa adapter was developed](https://arxiv.org/abs/2304.15010) with a technique called Parameter Efficient Fine Tuning (PEFT), which supercharged personalization/tuning even further. The LLaMA-Adapter, using PEFT, introduced a mere 1.2M learnable parameters, turning the model into a quick learner that could adapt in less than an hour. This breakthrough not only expedited the fine-tuning process but also democratized it, making high-level AI technology accessible, efficient, and user-friendly even on everyday devices. Also, by this point, open source GPT-3 models were already outperforming existing GPT-3 clones, proving that the community was no longer dependent on LLaMA.

This rapid growth in open source and individual LLMs has pressured both Google and OpenAI to reconsider their stance on model control. As the leaked [internal Google document published by SemiAnalysis](https://www.semianalysis.com/p/google-we-have-no-moat-and-neither) suggests, Google should establish itself as a leader in the open source community, taking the lead by cooperating with, rather than ignoring, the broader conversation. By embracing open source, LLM companies can continue to drive innovation while adapting to the changing landscape of AI development. If not, it seems likely they will be left behind.

## **In Conclusion**

With continually blurring lines between science fiction and fact, we're seeing the open source community drive innovation at an unprecedented pace, pushing established companies to rethink their strategies and embrace a more collaborative approach. At the same time, Enterprise AI products are still being released in droves while governments across the globe continue to grapple with regulation. This will only heighten as open source and pirated AI continue democratizing the technology.

As open source veterans, having worked on groundbreaking projects (such as PyTorch, Microsoft PowerToys, and React Native), we're incredibly excited to see and contribute to the growth of Open Source AI. We're also cognizant of the need to remain cautious and ensure that AI is used safely and responsibly (which is why we're proud to be incubating a first-of-its-kind, AI Safety start-up, led by our very own open source tech guru [Zak Greant](https://www.linkedin.com/in/zakgreant/?originalSubdomain=ch), but more on that later). The path ahead may be uncertain, but one thing is clear: the realm of AI is full of potential, and the coming months and years promise to be just as eventful as the last.

[Contact us](https://www.janeasystems.com/#lets-talk) to learn more about our AI/ML and open source work.

large_April AI roundup Blog.jpg

medium_April AI roundup Blog.jpg

small_April AI roundup Blog.jpg

thumbnail_April AI roundup Blog.jpg

April AI roundup Blog.jpg

Last Month in AI: LLM Privacy, Piracy, Personalization & Open Source

Over the last few months, Janea Systems has been working on a port of Node.js with ChakraCore to iOS. Now that things appear to be working well, we have created a demo app that showcases this work, and we’d like the feedback of the developer community to help us shape the future of the project.

> **UPDATE \[Oct 3rd, 2017\]:** The work described in this article has culminated in the release of Node.js for Mobile Apps: a full-fledged Node.js runtime for Android and iOS. Read the [announcement](http://www.janeasystems.com/blog/announcing-node-js-mobile-apps-true-node-js-runtime-android-ios/).

One of the many strengths that Node.js can claim under its belt is its ubiquity. From server to desktop to IoT, the Node.js runtime is available and generally well-supported on an [impressive list](https://github.com/nodejs/node/blob/1d60fc3aa5b7a6032665595c29bdb382bd526e43/BUILDING.md#supported-platforms-1) of operating systems and architectures.

Two major platforms, however, are conspicuously absent from the list: iOS and Android.

Why is that?

The reasons are both historical and technical. For one, Node.js was originally designed as a server platform, with assumptions that don’t always fit the app model and the unique challenges of mobile operating systems. But this reason alone would not have prevented developers from at least experimenting with Node.js on mobile. In fact, there have been a few reports already of people running Node.js on Android.

One issue, however, has completely prevented any attempts to make Node.js work on iOS: Apple does not allow Just-In-Time compilation on iOS (except for its own JavaScriptCore engine). The JavaScript engine that powers Node - Google’s V8 - relies on JIT compilation to execute JavaScript (even with the addition of the Ignition interpreter, V8 still needs to generate code at runtime, which does not comply with iOS’ restriction).

To be fair, somebody did manage to make Node work on iOS. [JXcore](https://github.com/jxcore/jxcore), a fork of Node based on version 0.10, added features specifically targeting mobile platforms and circumvented the iOS JIT restriction by adding the ability to use engines other than V8. By using SpiderMonkey in its interpreter mode, JXcore was able to run on iOS. JXcore also added other features and tooling to make Node fit well with mobile environments. Unfortunately in March 2016, Nubisa - the company behind JXcore - announced that they would no longer be working on the project. JXcore has made massive changes since the fork and meanwhile, development of mainline Node.js has continued at a dramatic pace; the two codebases have diverged so much that reconciling them is no longer practical and with JXcore still stuck at v0.10, it is clear that the project has reached a dead end.

Fortunately, other relevant efforts have emerged. Microsoft published [Node-ChakraCore](https://github.com/nodejs/node-chakracore), a friendly fork of Node which adds support for optionally using the ChakraCore engine instead of V8. Rather than modifying the Node source code to use a different engine, as JXcore did, they wrote a shim on top of ChakraCore which essentially emulates the V8 API. Thanks to this approach, the fork is much easier to keep in sync with the parent project; the two happily coexist under the Node.js Foundation and will likely be merged at some point.

Node-ChakraCore opens an opportunity for Node and iOS because ChakraCore has a well-optimized, 100% JIT-free interpreter mode. Even though it doesn’t officially support iOS at the moment, it was recently ported to macOS, which is not too far off.

The Janea team has been involved with these technologies for a while. We have been supporting JXcore for the [Thali](http://thaliproject.org/) project and we have been working closely with Microsoft on both the Windows port of Node.js and Node-ChakraCore. So a few months ago we decided to capitalize on the lessons learned from all those projects and started porting Node.js with ChakraCore to iOS.

We chose to focus on iOS first because we knew that it would be significantly more challenging than Android. With a little bit of effort, you can pretty much already run Node with V8 on Android (even though a lot more work needs to be done to make it an easy-to-use framework for mobile). It’s Node.js on iOS that truly breaks new grounds.

We have now reached a point where things seem to be working pretty well. Even though it’s still too early to publish a release, we wanted to at least share the news and show a demo.

### The demo

For the demo, we thought it would be interesting to showcase an integration of Node.js with React Native. React Native allows developers to write mobile apps primarily using JavaScript, while still having to write native iOS/Android code for things that are not covered by the framework. By adding Node.js to it, the hope is that developers will be able to do more with just JavaScript. While there are already solutions for using Node.js modules with React Native, having a real Node.js engine in the app should open up more opportunities and improve support for those modules.

The way we added Node.js to React Native is by starting Node.js on its own thread at application startup. Node and React Native each use their own JavaScript engine instance: ChakraCore and JavaScriptCore, respectively. In this particular implementation, the two JavaScript environments communicate via a combination of a REST API and WebSockets, which is a simple but effective approach that in principle allows to make calls, register callbacks, and pass JSON objects back and forth. While we chose to keep things simple in the demo, it would be easy to add some syntactic sugar on top of the REST API / WebSockets to make the interface between the frontend and backend even slicker.

The application allows the user to create photo albums and synchronize them with other users/devices. Synchronization happens between any number of devices and it works peer-to-peer, with no external server involved. Because of that, it only happens when the devices are on the same Wi-Fi network.

Node’s built-in dgram module is used for local network peer discovery, by means of UDP broadcast packets. The React Native portion of the app handles the UI. When a photo is added, it is stored in an in-memory database running in the Node layer, using PouchDB and MemDOWN. Back on the Node side, PouchDB handles the synchronization between devices. The REST API is provided by the express-pouchdb module, which starts a CouchDB compatible REST API on top of PouchDB, using the popular Express module. WebSockets is provided by the express-ws module, also on top of Express.

[Here’s a video showing the app in action.](https://www.youtube.com/watch?v=8Wx0kxWpvkY)

The demo source code is available [on GitHub](https://github.com/janeasystems/node-mobile-react-demo).

### Where do we go from here?

The possibilities for Node.js on iOS are certainly not limited to React Native. For starters, an integration similar to the one shown in the demo could be implemented for Cordova / PhoneGap (similarly to how [JXcore-Cordova](https://github.com/jxcore/jxcore-cordova) integrates Cordova with JXcore). Thali, which uses JXcore through JXcore-Cordova to provide rich peer-to-peer synchronization abilities, could certainly benefit from such a thing. Other mobile development frameworks, especially the ones based on JavaScript, could also be considered.

Of course, Node can also be added to any regular iOS application written in Objective-C or Swift. You would simply link the Node.js library with the application and add all the JavaScript code to the bundle. In your app startup code, you would then create a thread to execute the Node event loop and have it run the main script. You now have at your disposal the power of the Node.js built-in modules and the npm ecosystem.

So there are plenty of opportunities for future developments. At Janea, we intend to continue working towards making Node.js a powerful tool for iOS and Android development.

In the meantime, **we would love to hear your feedback** about all of this. How would you use Node.js on iOS and Android? What scenarios, features, or integrations would be most interesting to you? Please share your thoughts in the comments section.

For any further questions or suggestions, please don’t hesitate to [get in touch](/#contact). Also, don’t forget to subscribe to our social media channels and our newsletter, so that we can keep you posted about future developments.

large_Node.js-on-iOS.jpg

medium_Node.js-on-iOS.jpg

small_Node.js-on-iOS.jpg

thumbnail_Node.js-on-iOS.jpg

Node.js-on-iOS.jpg

Node.js meets iOS

Since we [released Node.js for Mobile Apps](http://www.janeasystems.com/blog/announcing-node-js-mobile-apps-true-node-js-runtime-android-ios/), the most requested feature has been support for Node.js native modules (also known as "C++ Addons"). This makes sense, since it is common for an npm module to either contain some native code itself or have a dependency on a module that does.

So we have been working hard to tackle this challenge. We are now excited to announce that support for native modules is available in the latest release of the React Native and Cordova plugins.

Being able to use these modules strengthens compatibility of Node.js for Mobile Apps with the npm module ecosystem, and opens a lot of possibilities for building mobile applications with Node.js.

### How to start using native modules with Node.js for Mobile Apps

With the latest release of [nodejs-mobile-react-native](https://www.npmjs.com/package/nodejs-mobile-react-native) and [nodejs-mobile-cordova](https://www.npmjs.com/package/nodejs-mobile-cordova), the plugins automatically detect the existence of native modules inside the \`nodejs-project\` folder in your app, and take care of building and packaging them as part of the application build process. It just works!

In the samples repo, you can find a [React Native sample app](https://github.com/janeasystems/nodejs-mobile-samples/tree/master/react-native/UseNativeModules) and a [Cordova sample app](https://github.com/janeasystems/nodejs-mobile-samples/tree/master/cordova/UseNativeModules) that include the [sqlite3](https://www.npmjs.com/package/sqlite3) and [sha3](https://www.npmjs.com/package/sha3) native modules, so you can try this feature right away.

### Node.js native modules and their challenges for mobile

[Node.js native modules](https://nodejs.org/api/addons.html) are Node.js packages that contain native code and instructions on how to build that native code using [node-gyp](https://github.com/nodejs/node-gyp). When installing a native module from npm, the default behavior is for the module to be built for the system on which npm is currently running. This makes sense when using Node.js on the server/desktop, where we can expect the required build tools to be available on the system, or for the module to be prebuilt and copied from a similar system. On mobile, however, this is either not practical or (on iOS) downright impossible; so we had to modify a few things to enable native modules to get cross-compiled and packaged with the application.

To that end, the plugins are using a [modified version of node-gyp](https://www.npmjs.com/package/nodejs-mobile-gyp) that is able to target the right OS and CPU architecture and include the Node.js headers from the Node.js for Mobile Apps release.

On iOS, we also need to ensure that the module binaries are packaged as a Framework signed with the application's signing identity and loaded from the application's /Frameworks path, which is required for loading dynamic libraries and for being accepted in the iOS App Store. Many thanks to [Patrick Chugh](https://twitter.com/patrickchugh), for all his help in validating iOS App Store submission with the [Shango App](https://github.com/neogeno/shango-lightning-wallet/blob/master/README.md).

On Android, we have to build a standalone toolchain before we can cross-compile native modules, and that needs to be done for each ABI supported by the application. We are able to support Universal APKs by packaging binaries for all the supported ABIs, and then choosing which binary to load at runtime.

Special care is also needed for modules the use [node-pre-gyp](https://www.npmjs.com/package/node-pre-gyp) to download a prebuilt binary, to ensure that they are actually built on the current machine and for the target OS and architecture.

All of that and more is handled automatically by the plugins, so developers don't even need to worry about whether their app uses native modules or not.

### Limitations and future work

Our goal was to ensure that as many existing native modules as possible work without modification on mobile. However, Node.js native modules are so flexible that it is not feasible to support every possible scenario. Modules that have non-standard build steps (e.g. depending on shell scripts rather than node-gyp, for building) may require further changes to work on mobile. Modules with platform-specific code or dependencies might need porting of that code to iOS or Android.

Given the large number of native modules out there, it would probably take our team a very long time to test and try to solve all the possible compatibility issues. So this is an area where we hope to get a lot of help from the community. To that end, we have created a [GitHub repository](https://github.com/janeasystems/nodejs-mobile-module-compat) where the community can discuss compatibility issues of existing modules with nodejs-mobile.

There are also other improvements to be made:

*   Adding support for building native modules for Android on Windows development machines (currently only macOS and Linux are supported).
*   Providing an easy way to use native modules in applications that are not using the \`nodejs-mobile-react-native\` or \`nodejs-mobile-cordova\` plugins.
*   Being able to use an installed NDK instead of building a standalone NDK toolchain for Android.

### A whole new world of possibilities

Having native modules opens a whole new world of possibilities for using Node.js for Mobile Apps. Our [community Gitter channel](https://gitter.im/nodejs-mobile/community) has been filled with questions and experiments on this topic. We can't wait to see what sort of novel and creative applications can be developed now that native modules are supported out of the box.

We invite you to try using Node.js with native modules in your mobile applications, and to get involved with the project. Provide feedback, report bugs, suggest improvements, contribute code. Go build amazing new apps and radically new frameworks with it!

To get started, visit the [Node.js for Mobile Apps website](https://code.janeasystems.com/nodejs-mobile).

medium_nodejs-mobile-1024x512-closeup-c.jpg

small_nodejs-mobile-1024x512-closeup-c.jpg

thumbnail_nodejs-mobile-1024x512-closeup-c.jpg

nodejs-mobile-1024x512-closeup-c.jpg

Support for native modules in Node.js for Mobile Apps

Node.js

Several billion-dollar tech companies lose money every year. For example, Snap and Uber made billion-dollar losses between them last year. What do companies like these have in common? They have vast amounts of data, and in today's digital era, data has become a commodity more valuable than gold.  

As the age of AI dawns upon us, one fact has become clear - for generative AI to work efficiently, it requires data and lots of it. Diverse, representative, and bias-free data is not just a "nice to have" but a necessity for creating accurate AI models before methodologies such as supervised, semi-supervised, unsupervised, reinforcement, and transfer learning are used to build effective AI systems. But the intangibility and novelty of AI can make it easy to overlook how LLM (Large Language Model) providers acquire and process data.  

## The AI Data Supply Chain  

As we've grown more globally conscious, we've seen increasing calls for transparency within supply chains - from lithium mining for electric cars to growing cotton for fast fashion. Many industries that deal with physical products succeed because of the ability to utilize cheap labor within supply chains, often from those residing in the global south.  

Within generative AI, we can draw parallels in supply chains (not just in the materials that power the hardware but also) when it comes to sourcing and [processing data](https://time.com/6247678/openai-chatgpt-kenya-workers/).  

## The Ethics and Economics of Selling Data  

Monetizing user data is not a novel concept. Web 2.0-centered platforms like Facebook pioneered this business model to serve highly targeted and profitable ads. While this approach has led to the explosive growth of numerous tech companies, it hasn't been controversy-free, as the Cambridge Analytica scandal shows.   

Today, we're entering a phase where data is no longer just analyzed for insights or to power ads. It's being used to train generative AI models, and (ironically) the companies that have profited most from user-generated content on their platforms are now fighting with LLM providers for the data you put on their platforms.  

Social media networks such as Reddit, Twitter, and Stack Overflow have announced plans to [charge LLM providers for using their (or your) data](https://gizmodo.com/stack-overflow-charging-ai-companies-for-training-data-1850362500). We've recently seen [a spate of lawsuits](https://www.rollingstone.com/culture/culture-news/sarah-silverman-copoyright-suit-chatgpt-open-ai-1234785472/) over copyright issues outside of user-generated content, with LLM providers facing accusations of using copyrighted works to train their algorithms. This shift is underscored by [Google's recent change in its privacy policy](https://www.theverge.com/2023/7/5/23784257/google-ai-bard-privacy-policy-train-web-scraping), permitting publicly available online data to be used in training its AI systems, showcasing how data is fast becoming a pivotal player in the evolving landscape.  

In this intricate landscape, many profitable and non-profitable tech companies continue operations banking on their data repositories. They believe these vast data reserves could drive future profitability, especially as the demand for diverse data to train AI systems amplifies.  

## The Legal Landscape: Data Scraping and Intellectual Property Issues  

Navigating the legal aspects of this evolving data landscape is complex. Scraping/collecting public data on the web is not illegal; although many websites include terms that prohibit data scraping, there's not really any way to stop it. Copyrighted data is not illegal to collect, but it is illegal to use without the owner's permission. However, as generative AI platforms don't tend to disclose their training data, in most cases, it's difficult to prove that copyrighted data has been used (but [there are some exceptions](https://www.theverge.com/2023/1/17/23558516/ai-art-copyright-stable-diffusion-getty-images-lawsuit)). Under most laws, collecting or using personally identifiable information, such as names and addresses, is illegal without the owner's explicit permission. However, personal information is often publicly available and easily accessed, making it possible for scraped personal data to train LLMs, without the owners' knowledge. This leaves identifiable information open to data extraction attacks [like this one carried out on Open AI's older LLM, GPT-2](https://arxiv.org/abs/2012.07805).  

## Tech Company's Role in the Data Trade  

Ultimately, the data economy creates new ethical imperatives and social responsibilities. As stewards of user data, tech leaders play an outsized role in driving the moral compass of AI systems influencing society.  

Creating organizational frameworks to assess the risks and moral implications of data-driven technologies is indispensable, as analyzing AI ethics tradeoffs can be complex. Keeping diversity, inclusion, and equity at the heart of AI development to stop biased AI systems is vital.  

The data revolution marks a watershed moment in technology's relationship with society. As trailblazers guide its trajectory, data scientists and software engineering leaders bear profound responsibility. By tirelessly championing transparency, ethics, and human welfare, we can illuminate data's immense potential to be a force for good. The choices we make today will profoundly shape our collective digital future.  

## The Individual's Role in Data Trade 

In a world where "if it's free, you're the product," the implications for us as individuals are substantial. Our data is quickly becoming a commodity for AI training, positioning us as inadvertent data suppliers. The Black Mirror episode "Joan Is Awful" vividly highlights the potential misuse of the data we sign away in lengthy terms and conditions agreements, urging us to contemplate our privacy and security in this evolving data economy.  

## Conclusion  

As we continue to wade through the complexities of the emerging data trade, striking a balance between advancing AI and preserving privacy becomes crucial. Awareness of our digital footprint's value and its implications in the new data economy is more important than ever. So as platforms continue the fight to commoditize your data, will you think twice before posting your thoughts online?

large_Generative AI data trade.jpg

medium_Generative AI data trade.jpg

small_Generative AI data trade.jpg

thumbnail_Generative AI data trade.jpg

Generative AI data trade.jpg

If It's Free, You're the Product: The New Data Trade in Generative AI

[Bartosz Sosnowski](https://twitter.com/bzoz_) and [João Reis](https://twitter.com/joaocgreis) of Janea Systems have made enhancements to Visual Studio Code that enable launching and debugging Node.js in the Windows Subsystem for Linux. Read the [MSDN blog article](https://blogs.msdn.microsoft.com/commandline/2017/10/27/running-node-js-on-wsl-from-visual-studio-code/) to learn more.

large_Debugging Node.js with VS Code and WSL Blog Image.png

medium_Debugging Node.js with VS Code and WSL Blog Image.png

small_Debugging Node.js with VS Code and WSL Blog Image.png

thumbnail_Debugging Node.js with VS Code and WSL Blog Image.png

Debugging Node.js with VS Code and WSL Blog Image.png

Debugging Node.js with VS Code and WSL

Company News

Recent reports have [highlighted significant drops in traffic](https://www.similarweb.com/blog/insights/ai-news/stack-overflow-chatgpt/) for, the popular programmer question-and-answer site, Stack Overflow. The finger of blame is being pointed squarely at AI chatbots like ChatGPT and GitHub's CoPilot. 

## Stack Overflow's Decline

According to SimilarWeb, Stack Overflow has seen a steady decline in its traffic since the start of 2022. Considering AI shows no signs of stopping, and stackoverflow.com's traffic decreased by [17.75%](https://www.similarweb.com/website/stackoverflow.com/#traffic) from March to April this year, it's no wonder the company is taking measures to minimize generative AI’s exposure on the forum. Arguing that ChatGPT is often inaccurate, the Stack Overflow team [announced a ban on posting ChatGPT content to its site](https://meta.stackoverflow.com/questions/421831/temporary-policy-chatgpt-is-banned) at the end of last year. They've also announced [plans to charge LLM companies](https://www.wired.com/story/stack-overflow-will-charge-ai-giants-for-training-data/), like OpenAI, for the data on their platform from as early as this year. 

## Why Developers are Turning to AI

In a landscape where time is of the essence and amidst a backdrop of major tech layoffs, many developers are finding solace in the immediacy of AI solutions like ChatGPT. Why wait for a response on a forum when a sophisticated AI can generate a potential solution in real time?

## Our Software Engineers' Perspectives

Despite this scenario painting a grim picture of debugging forums, here at Janea, we're not convinced that generative AI will be the end of the likes of Stack Overflow. Here’s why:

We, as a team of open source advocates, truly appreciate the beauty of platforms rooted in a community-driven approach, and we know that many developers feel the same way. We asked our expert software engineers:

How do you see the role of generative AI tools in relation to community-driven debugging forums?

*   As a complete substitute for these forums. 0%
*   As a substantial but not total substitute. 22%
*   **As a complementary tool to these forums. 78%**
*   As unrelated and non-impacting to these forums. 0%

Software Engineer [Vedran Grudenic](https://www.linkedin.com/in/vedran-grudenic/), also brought up an important point:

> “If the trend continues, future LLMs won't have as many reliable and up to date Q&A sources to train on.”

In addition to posting questions and getting answers, forums like Stack Overflow facilitate meaningful conversations and debates about the merits and demerits of different solutions. As sophisticated as it may be, this culture of collaboration and knowledge sharing is something that AI cannot replicate.

AI-generated solutions, while impressive, are not infallible. They provide a good starting point but often need to be tweaked and fine-tuned to meet specific needs.

As David Carr from SimilarWeb eloquently put it, "The answer that comes back may not be exactly what the developer needs but is often close enough to be shaped and tweaked into a working solution." 

## The Future of Debugging Code

Stack Overflow is already acknowledging the shift and looking to leverage AI to enhance its offerings. In a [statement to Gizmodo](https://gizmodo.com/stack-overflow-traffic-drops-as-coders-opt-for-chatgpt-1850427794), Stack Overflow's Matt Trocchio confirmed that approximately 10% of the company is working on features leveraging generative AI.

At this point, it's too early to tell if the rise of generative AI will lead to the death of debugging forums. With Stack Overflow’s [plans to incorporate AI into their platform](https://stackoverflow.blog/2023/04/17/community-is-the-future-of-ai/), it's likely that we will soon witness an evolution of how we debug code, with generative AI working in unison with developers instead of competing against one another.

In the world of tech, change is the only constant, and AI's disruptive nature will continue to change the landscape in exciting and challenging ways. We're at the very beginning of seeing AI tools and community-led platforms converge. While the impact of generative AI is still unfolding, the future of programming is bright, so whether you're a seasoned developer or a newbie, stay flexible, keep learning, and, most importantly, keep coding.

To learn more about how our team helps the largest software-centric companies overcome their software engineering challenges, get in contact [here](https://www.janeasystems.com/#lets-talk).

large_Blog Feature Image Will Generative AI Stack Overflow.jpg

medium_Blog Feature Image Will Generative AI Stack Overflow.jpg

small_Blog Feature Image Will Generative AI Stack Overflow.jpg

thumbnail_Blog Feature Image Will Generative AI Stack Overflow.jpg

Blog Feature Image Will Generative AI Stack Overflow.jpg

Will Generative AI Mean the End of Debugging Forums?

Over the past few months, we've seen a flurry of vocal billionaires bad-mouth working from home. [James Dyson](https://www.businessinsider.com/james-dyson-slams-uk-flexible-working-policy-self-defeating-2022-12?r=US&IR=T) says the concept is "staggeringly self-defeating." [Elon Musk](https://www.cnbc.com/2023/05/16/elon-musk-work-from-home-morally-wrong-when-some-have-to-show-up.html) says it's "morally wrong," and [Alan Sugar](https://www.independent.co.uk/arts-entertainment/tv/news/lord-sugar-gmb-twitter-b2156348.html) has gone as far as to say that companies should pay remote employees less.  

With Covid-19, thankfully, behind us, many tech companies, including Netflix, Amazon, Apple, Google, and IBM, are rolling out a hard reset on WFH protocols and demanding employees return to the office. The majority are enacting hybrid working policies, but going from remote working to four days in the office is a significant change. There's been considerable backlash, especially as many of these organizations previously committed to a "remote first" approach to work. 

## Who's being forced back into the office, and how's it gone down with employees?

Here's a snapshot of some tech companies that have changed their working from home policies over the last few months. 

**Meta**: Meta has [stopped offering remote work](https://www.businessinsider.com/meta-stops-offering-remote-work-new-job-postings-zuckerberg-2023-3?r=US&IR=T) in new job listings.

**Snap:** [Snap employees will be required to return to the office at least four days a week as of February 2023](https://www.businessinsider.com/snap-return-to-office-mandate-2023-2022-11). 

**Amazon:** [Insider reports](https://www.businessinsider.com/amazon-employees-plan-to-fight-against-return-to-office-policy-2023-2?_gl=1*1pz7g5d*_ga*MTE5MzA1ODM2Ny4xNjc2ODgxMjQx*_ga_E21CV80ZCZ*MTY3NzA1MzY3OS41LjAuMTY3NzA1MzY4MC4wLjAuMA..&r=US&IR=T) thousands of Amazon employees joined a Slack channel to share their thoughts on Amazon's return-to-office policy. Some are organizing to file a petition against it[.](https://www.businessinsider.com/amazon-employees-plan-to-fight-against-return-to-office-policy-2023-2?_gl=1*1pz7g5d*_ga*MTE5MzA1ODM2Ny4xNjc2ODgxMjQx*_ga_E21CV80ZCZ*MTY3NzA1MzY3OS41LjAuMTY3NzA1MzY4MC4wLjAuMA..&r=US&IR=T)

**Apple**: '[Apple workers hit back against the company's return-to-office plans, saying they have carried out 'exceptional work' from home](https://www.businessinsider.com/apple-employees-remote-work-office-three-days-2022-8).' 

**IBM**: [IBM CEO says employees' careers could suffer, and it'll be harder to get a promotion working from home](https://www.businessinsider.com/ibm-ceo-remote-work-employees-careers-promotions-suffer-2023-5)

## Is the rush back to the office worth it?

While the bosses in the headlines tend to focus on the morality of working from home, fostering a good working culture, and employee wellbeing, you have to consider the bottom line; office leases are not cheap. The financial impact of maintaining vacant office spaces and the business loss from employees not being physically present leave the corporate ecosystem in a precarious position. For example, in February, [Bloomberg reported](https://www.bloomberg.com/graphics/2023-manhattan-work-from-home/) that New York City alone is losing $12 billion yearly because of remote work. So, on the one hand, WFH is bad for business. Still, a recent study has shown it's better for software engineers' productivity.  

## Hybrid working and Software Engineers

Last month, Microsoft and Vista Equity Partners published a study entitled "[Best of Both Worlds: Unlocking the Potential of Hybrid Work for Software Engineers](https://www.microsoft.com/en-us/research/uploads/prod/2023/05/BestOfBothWorlds.pdf)." Its findings may shed some light on the sentiments behind the backlash outlined above. The study surveyed 3,456 engineers at 28 companies 'to identify challenges and opportunities facing developers in the hybrid world.' 

One of the key results found from the study is that developers working entirely remotely report the highest level of productivity. This data can't be extrapolated to cover all office-based employees from the companies we touched on above. Still, software engineers are office-based workers and will most likely be included in the return-to-office policies that many tech companies are enacting.  

![office returns study image.png](https://cloud-cube-us2.s3.amazonaws.com/nqnr0sjjo9vs/public/office_returns_study_image_7284cc9356.png)![](https://www.janeasystems.com/wp-content/uploads/2023/06/image.png)

It's worth noting that the majority of the respondents surveyed worked entirely at home.

![Office returns study image 1.png](https://cloud-cube-us2.s3.amazonaws.com/nqnr0sjjo9vs/public/Office_returns_study_image_1_9e58b0fdf9.png)

![](https://www.janeasystems.com/wp-content/uploads/2023/06/image-1.png)

There are also other nuances to consider. For example, the study also asked about what aspects of going into an office are valuable and engineers' biggest work challenges.

![](https://www.janeasystems.com/wp-content/uploads/2023/06/image-2.png)![](https://www.janeasystems.com/wp-content/uploads/2023/06/image-3-1024x660.png)

![Office returns study image 2.png](https://cloud-cube-us2.s3.amazonaws.com/nqnr0sjjo9vs/public/Office_returns_study_image_2_6d7b4ef704.png)

![Office returns study image 3.png](https://cloud-cube-us2.s3.amazonaws.com/nqnr0sjjo9vs/public/Office_returns_study_image_3_eea43c5af2.png)

In both of these cases, social interaction is the leading factor when it comes to the onsite/offsite working debate. You would think that fully onsite developers wouldn't report a lack of social interaction, but, in reality, the study shows they are 8% more likely to miss social interactions than entirely remote developers. It's also worth noting that those who reported missing social interactions feel just as productive as those that didn't.

Here at Janea, we've been remote native since our inception, and we're sure that developers are just as productive, if not more productive, working from home. We understand the challenges that come with working remotely, and we have several working practices in place to overcome them, such as: 

*   We have a company-wide meetup at least once a year. 
*   Employees are encouraged to meet up and have the option of working from a coworking space. 
*   We provide employees with a generous [stipend for office equipment](https://usc-word-edit.officeapps.live.com/we/behind%20the%20Screens:%20A%20Peek%20into%20Janea%E2%80%99s%20Remote%20Native%20Home%20Offices%20-%20Janea%20Systems). 
*   We provide great salary packages with more than enough to pay for a good internet connection and a fan for the summer months. 
*   We offer truly flexible working hours.

Developers are at the heart of Janea System, and it's because of this that we're committed to supporting developers' needs, both professionally and personally. After all, our CEO is a seasoned developer himself. We've seen firsthand how software engineers thrive when they're given the flexibility to manage their own schedules, and our ongoing work with the largest, software-centric, fortune 500 companies is a testament to this.

To our fellow software engineers who may be pushing back on the WFH reset, we hear and stand with you. Ultimately, it's not just about where we work but how we work best. Our own experiences, corroborated by the Microsoft study, show that productivity doesn't stem from being physically present in an office but mentally present in our work - wherever that might be. 

Want to join the best and the brightest software engineers? View our open positions [here](https://www.janeasystems.com/current-openings/).

large_WFH blog (1).jpg

medium_WFH blog (1).jpg

small_WFH blog (1).jpg

thumbnail_WFH blog (1).jpg

WFH blog (1).jpg

Tech Companies' Office Returns Clash with Study on WFH and Software Engineer Productivity 

In our ongoing quest to improve [Node.js for Mobile Apps](https://code.janeasystems.com/nodejs-mobile) (a.k.a Node.js Mobile), we have just completed a series of major improvements and made them available in the latest release. Of course, in delivering these improvements, we have paid close attention to the desires and feedback of our valued users, as always.

## **V8 JavaScript engine now on iOS**

Probably the most noteworthy update is the use of the V8 JavaScript engine on iOS. This replaces the ChakraCore engine that was used previously on Apple devices. With this update, Node.js relies on the same engine on both Android and iOS, ensuring consistent behavior and reliability across all devices.

Previously, when we used V8 on Android and ChakraCore on iOS, some specific code cases behaved differently due to implementation differences between the two engines. Some APIs were available on one platform and not the other. These issues are now eliminated.

The use of V8 on iOS was made possible by the engine now supporting a JIT-less mode, since its [7.4 release](https://v8.dev/blog/jitless).

## **Based on Node.js 12.16 LTS (Long-Term Support)**

The latest release is based on Node.js 12.16 LTS (Long Term Support), and has all of the latest security fixes patched into the software. Node.js 12 is the active LTS version, until [Node.js 14](https://nodejs.org/en/about/releases/) enters LTS on Oct. 20, 2020.

This also offers access to more recent APIs, such as 'worker\_threads', which make it possible to run JavaScript on more than one thread. This is an innovation that has been strongly desired among the Node.js Mobile community, and we're delighted that we can deliver it as required.

There is also ES6 JavaScript module support included, and the system now contains a more recent N-API version, which ensures improved module compatibility. 

The Node.js Mobile codebase is now rebased on the main [Node.js repository](https://github.com/nodejs/node/) instead of [node-chakracore](https://github.com/nodejs/node-chakracore). This will make it easier to keep up to date with future LTS versions and security vulnerability fixes. 

## **Built with V8 snapshots for Android**

The new release has been built with V8 snapshots for the Android version. Since V8 and Node.js internal JavaScript code are pre-initialized to be directly loaded into the heap, faster startup and run times are possible. Users on our [community channel](https://gitter.im/nodejs-mobile/community) have reported application launch time reductions of 50%. 

The challenge in building Node.js Mobile with snapshots was the cross-compiling of V8 and Node.js, while also having to build the snapshots to run on a different OS and CPU architecture.

With this recent release, Node.js Mobile is more powerful than ever. [Check out](https://code.janeasystems.com/nodejs-mobile/getting-started) the new changes, and we would love to know what you think!

Interested in exploring the possibilities of Node.js on mobile devices or Node.js application development? If so, [contact our consulting services team](http://www.janeasystems.com/#contact) to find out how we can help.

medium_Blog-Feature-Image-Node.js-for-Mobile-Apps.jpg

small_Blog-Feature-Image-Node.js-for-Mobile-Apps.jpg

thumbnail_Blog-Feature-Image-Node.js-for-Mobile-Apps.jpg

Blog-Feature-Image-Node.js-for-Mobile-Apps.jpg

Significant Updates in the New Release of Node.js Mobile

The Janea team currently spans 21 countries over four continents. Being a remote native company, we can't share "bring your dog to work" or office team photos, but that doesn't stop us from mingling through a screen or three. Last month, what started as a simple request for webcam recommendations soon spiraled into a 100+ message slack thread of our team sharing their workstations, featuring some (shall we say) interesting ornaments.

Take a peek at some of our team's setups.

### **The Minimalists**

![minimalist.png](https://cloud-cube-us2.s3.amazonaws.com/nqnr0sjjo9vs/public/minimalist_20ce7d0283.png)

Modern, minimalistic, with some snazzy tech. Very fitting for our Senior iOS Developer, [Denis Bogomolov](https://www.linkedin.com/in/manwithbear/).

![minimalist2.png](https://cloud-cube-us2.s3.amazonaws.com/nqnr0sjjo9vs/public/minimalist2_c80d664939.png)

[Marcell](https://www.linkedin.com/in/marcellcsomor/), our Business Operations Manager, takes good care of his plants.

## **Mood Lighting**

A couple of the team members like a little _**ambiance**_ while they work.

![Marcell Keyboard Lighting.png](https://cloud-cube-us2.s3.amazonaws.com/nqnr0sjjo9vs/public/Marcell_Keyboard_Lighting_0666d70de4.png)

**![](https://lh4.googleusercontent.com/sB976efT0IGsRjSWPb-Xw6kiOWhmPNGByKIGfUymDDgS8T3lQaSB-yiUkSVnP8chAhLqX_26rUr5Ouyiqe3e9pJt8L1QnkvFSYSBeh_EsPhvVsRnffGo3KDqB4k4QWlZlhrVmbzKgfrh8tyWtcw2qI0)**

Marcell’s also a big mechanical keyboard advocate.

![](https://lh3.googleusercontent.com/ax-94a5P--u9ZlukgUA2Zm7gUkOoPj3dbCWU42QrEi_6wm6c5E0vuq7Fi24w2W7kVS9at0nKpAoW0qyxOe359ZNCd5XgsjonWfgjtF5n81bDeT158rnWjcj1eeSOeYaSNq4WinQeiPNRMDsD4cUmkYI)

![Pjero Keyboard.png](https://cloud-cube-us2.s3.amazonaws.com/nqnr0sjjo9vs/public/Pjero_Keyboard_4e727d95d0.png)

[Pjero](https://www.linkedin.com/in/pjero-ni%C5%BEeti%C4%87-8b3b95182/), our Front End Software Engineer, is partial to some mood lighting.

## **The Lego Enthusiasts**

![Filip workspace 1.png](https://cloud-cube-us2.s3.amazonaws.com/nqnr0sjjo9vs/public/Filip_workspace_1_bbb8d610ef.png)![Filip workspace 2.png](https://cloud-cube-us2.s3.amazonaws.com/nqnr0sjjo9vs/public/Filip_workspace_2_6e948eb215.png)![Filip workspace 3.png](https://cloud-cube-us2.s3.amazonaws.com/nqnr0sjjo9vs/public/Filip_workspace_3_0b68d6234d.png)

Our Lead Software Engineer, [Filip](https://www.linkedin.com/in/filip-proborszcz-38844340/), is never far from a drum set.

​​

![Mike W Workspace.png](https://cloud-cube-us2.s3.amazonaws.com/nqnr0sjjo9vs/public/Mike_W_Workspace_e98f455e7c.png)

Cozy, approachable, and ergonomic, just what you’d expect from our Head of People Operations. [Mike’s](https://www.linkedin.com/in/mikewrightshef/) a big DIY enthusiast and he built this desk himself.

Mike and Filip also bonded over their shared love of Lego, having built the same Lego Bonsai.

## **The Three-Screeners**

![](https://www.janeasystems.com/wp-content/uploads/2023/04/three-screeners-stefan-1024x222.png)

![Stefan 3 monitor setup question.png](https://cloud-cube-us2.s3.amazonaws.com/nqnr0sjjo9vs/public/Stefan_3_monitor_setup_question_e5b09aef85.png)![Stefan Setup.png](https://cloud-cube-us2.s3.amazonaws.com/nqnr0sjjo9vs/public/Stefan_Setup_5b9f0369d8.png)

You’re not [Stefan](https://www.linkedin.com/in/stefan-stojanovi%C4%87-347009151/) (Senior Software Engineer).

![](https://lh4.googleusercontent.com/6WZlENC29TX7IurRIhGSDjtvEk8ZQ-ZxPnFUzshThqgseKjfYqJdO3OYyXUdvollOaiSDL4Tp-rn-tgpQB7xO56zdPAeUH0739qvTTlzSk3NLDtzU66FDFG42X0wwLbSqYZjibNyN7z5E8bqeeP92Hs)

![Jaime Setup.png](https://cloud-cube-us2.s3.amazonaws.com/nqnr0sjjo9vs/public/Jaime_Setup_4052f7da1c.png)

[Jaime](https://www.linkedin.com/in/jaimecbernardo/), our Lead Software Engineer, is also part of the three-screen crew. 

![](https://lh6.googleusercontent.com/kzx0m3hN6xuvHqsXTvJ8j1ToQa1t8L8WzS_D4DkjoKVjKXm4P5wuqZaDDAwDMtwd3v3fwG3XucemPPDdpUV_4KE2ogPqBWBSxlIuCb2BsyDNau2_zoqrbrmFDHemUs1sCfzVzop9nS-iuNz2el-hCA4)

![Mike Decerbo Setup.png](https://cloud-cube-us2.s3.amazonaws.com/nqnr0sjjo9vs/public/Mike_Decerbo_Setup_2617ab85d0.png)So is [Mike](https://www.linkedin.com/in/michaeldecerbo/), our CEO, with his super wholesome desk.

## **The Weird and Wonderful (maybe just weird)**

![](https://lh6.googleusercontent.com/4dq7qcJ4-oMGRLsKIK0XXj2sspfY3ceLpGRLopXPbqucYDZCTX8EDeI5Vt_LDUlTx1gmEredXkO4w6cvEQVKLceHHxGm0175hGdeCDVPpgAyRZCtCmWHN8sULqC1PQHxwW0poCl_G3GRY4dNC-8_BD4)

![Artur Setup.png](https://cloud-cube-us2.s3.amazonaws.com/nqnr0sjjo9vs/public/Artur_Setup_ae56873b04.png)

Senior Software Engineer, [Artur](https://www.linkedin.com/in/arturyapparov/), took a different approach and decided to share a gift from his 2-year-old that’s very close to his heart. 

![](https://lh3.googleusercontent.com/Lr2kfU4DGBTJo6zwJpJLcbeMhMbMRYGy7RyluIUNfCS1RdzTZKGst4w0mQSOEv7OOEXeOA7OoXqAFBAb5p6DwhMf-416I4g-1iQcfNxiitUOozY_PX7N0Rlt8aISOwWwRvD8V-4eNhM5VCs6DaoTJXk)

![Roko Setup.png](https://cloud-cube-us2.s3.amazonaws.com/nqnr0sjjo9vs/public/Roko_Setup_8a4c901f68.png)

Following on from Artur, [Roko](https://www.linkedin.com/in/rokofakles/) (Recruitment Operations Manager) doesn’t take the most conventional approach to remote working. Just keep your camera off and mute when necessary, please.

## **The Foodstation/Workstation**

![](https://lh4.googleusercontent.com/vcTQVw2yGUsp1iNeA012s-rf6-4DFv3Q_B5AFXzKmVEiFig3H-Gf6jJRtm3rNZD4w40Me06G8W-3ymMKwEtb7d2_X1MAdSZ6zKG2Txm9Yatu5Yw53uPqqddWhP1uHd42bjaDplIZP-hsnbEgoP4lxWA)

![Veronika Setup.png](https://cloud-cube-us2.s3.amazonaws.com/nqnr0sjjo9vs/public/Veronika_Setup_ea5f89abff.png)

Uncomplicated and efficient, [Veronika](https://www.linkedin.com/in/veronikabagari%C4%87/), our Senior Global Technical Recruiter, doesnt need bells and whistles to be effective.

![](https://lh6.googleusercontent.com/_CgHEZJtCQQ7yT3YaNs2f3dSN0HZwG6JJcmsOV6YXtrHtNP4XF5Kp2VVzOGcqgrjNLTjtaX-kzmk2sC26XhpxFPbFlPz35krQZrQeDFQwiHsO-kzZKKClQ0n7wYTFK8rjU3gboNHR9qynV9cJ67YdJ4)

![Jelena Setup.png](https://cloud-cube-us2.s3.amazonaws.com/nqnr0sjjo9vs/public/Jelena_Setup_bc7bda9f88.png)

It looks like we have an artist in our midst. If you look closely, you’ll see that Jelena, our Technical Recruiter, has brought the Sahara to Croatia. 

## **The Oldschooler**

![](https://lh3.googleusercontent.com/waByrA1Rr0y0VJV2Mm7KaewnVLfX6W15cgsKfwYdfQpMX-GJEKbob0DD_4PyzHnVQuESk6wfozNVVN8X_3qM53QO19OZ3qtzs5NCqEBfdMBxJnUKb3FNrkpLDeNYphVOc_SBpvP6dHKhAduDcrG5NDY)

![Marek Setup.png](https://cloud-cube-us2.s3.amazonaws.com/nqnr0sjjo9vs/public/Marek_Setup_91ebf90020.png)

Yes, that is a pretty old monitor, but it works well for Software Engineer, Marek, and if it isn’t broken, don’t fix it.

## **The Music Lover**

![](https://lh4.googleusercontent.com/QS1nNDi0Fr8lzF3FFUahZ5YV48dBjBBkEFVpClHTEWe1t9STVmC8yk6RZn-Nys0qJlY-pDGIFmAjS4JoDNQ-r9cGkYIeJnV09tK-B2BL6D4BOI7QGzykbPkgbiZVWuqXhJmSvfajAstT67KpW2EDsnI)

![Zak Setup.png](https://cloud-cube-us2.s3.amazonaws.com/nqnr0sjjo9vs/public/Zak_Setup_5f31063f83.png)

Another sprucy setup. It’s no wonder [Zak](https://www.linkedin.com/in/zakgreant/), VP of Strategy, frequently contributes to the #chillout-music channel.

## **The Winner**

![](https://lh3.googleusercontent.com/wzwS9c10nMa-V74LgzgkbuzLxKvFXX8GVEwW51LLtyDxdpM0tcd2fqhVrk89tg2ocSlDGs_c9QEzHk3fP6nBwTXI15K_R_Jme6OjH_3MU1m5C5dDh4LgsGMqukNOLtN4adTXJirtr5eRdIDx_8HugZ8)

![Alexis Setup.png](https://cloud-cube-us2.s3.amazonaws.com/nqnr0sjjo9vs/public/Alexis_Setup_19c87a7eac.png)

Hands down, the snazziest of us all. Our Founder and Chairman of the Board, [Alexis](https://www.linkedin.com/in/alexisca/), likes to lean back while he’s working. It wasn’t a competition, but if it were, he would win. 

Being a remote native company allows us to recruit the best talent from across the globe, and our culture of trust and hard work means that our colleagues can be flexible with their working hours. We provide our employees with a (perhaps underutilized) allowance to get the necessary equipment to set up their office. We’re proud to have a diverse workforce, and although we’re working from home most of the time, we have a company-wide meetup a couple of times a year too.

![](https://lh6.googleusercontent.com/6KstQ3YLj0rJPuV68sIdkXpSbwAGQ-riRlVHHdT4l53ao5rMQseITNwzlfZdi4DLoOaJzguKYMLN_VhR9sk48rLWOaCK7rPqSwudisilbcUji93sgNE-0EzvIscQIhfQIzicunNprfLGQcSiLUHun-I)

Want to join our world-class team? View our open positions [here](https://www.janeasystems.com/current-openings/).

large_Behind-the-screens-blog-1-1024x536.jpg

medium_Behind-the-screens-blog-1-1024x536.jpg

small_Behind-the-screens-blog-1-1024x536.jpg

thumbnail_Behind-the-screens-blog-1-1024x536.jpg

Behind-the-screens-blog-1-1024x536.jpg

Behind the Screens: A Peek into Janea’s Remote Native Home Office

Earlier this year we published a demo app showcasing our port of Node.js with ChakraCore to iOS. In the accompanying [blog article](http://www.janeasystems.com/blog/node-js-meets-ios/), we talked about how Node-ChakraCore opened a unique opportunity for Node.js to work on iOS, and consequently a path for Node.js to become a viable building block for mobile applications.

The engineering team at Janea Systems has continued to work hard and passionately on this project; so today, we are excited to announce the first alpha release of [Node.js for Mobile Apps](https://code.janeasystems.com/nodejs-mobile): a toolkit that enables developers to harvest the power of Node.js and its module ecosystem in their mobile applications. At the heart of it, is a library - available for Android and iOS - that allows an app to host a full-fledged Node.js execution environment. In addition to the core library, we have released plugins for Cordova and React Native - both also compatible with Android and iOS - which make it extremely easy to integrate the Node.js runtime into applications built using on those frameworks.

The project is still at an early and experimental stage, but you can start building your apps with it today.

And like most best things in a developer's life, [Node.js for Mobile Apps](https://code.janeasystems.com/nodejs-mobile) is **free and open source**. :)

### The power of Node.js inside your mobile apps

With Node.js for Mobile Apps, you get a Node.js execution environment running in a background thread inside your app. This environment is well suited for business logic, advanced networking, and background processing, but it can pretty much run any code that can be executed asynchronously from the UI, while leaving synchronous UI handling to the main application thread.

To facilitate communication between the Node.js code and other parts of the app, we have implemented a high-performance messaging channel that can be used to send data back and forth. It is a low-level primitive that is effective in and of itself, but could also be used in the future to build higher-level abstractions on top of it, like cross-thread method invocations and callbacks.

For example, in a React Native app you can do:

```javascript

import nodejs from 'nodejs-mobile-react-native';
...
 nodejs.start();
 nodejs.channel.addListener('message',
 (msg) => {
 alert('Received from node: ' + msg);
 },
 this
 );
...
<Button title="Send something"
 onPress={() => nodejs.channel.send('something')}
 />
```

JavaScript code can also make direct synchronous calls into native code (Java, Objective C, Swift) and get calls back from it, by means of Node's native add-on APIs (the V8 API and N-API are both available).

And of course, you can use modules. We have done a good amount of testing with PouchAlbum - our demo app - which includes more than 300 modules. So even though there's more work to be done to fully assess and ensure compatibility of the module ecosystem, there are reasons to be happy about the current state of affairs.

### A highly-compatible Node.js engine under the hood

Today's release of [Node.js for Mobile Apps](https://code.janeasystems.com/nodejs-mobile) is based on source code from Node.js v8.4.0.

The Android version of the core library uses the V8 JavaScript engine - much like regular Node. So it is very similar to a Linux build of Node.js, but with a few platform-specific tweaks and fixes.

On iOS, V8 cannot run because the operating system forbids just-in-time compilation; so instead of V8, we used our own port of the ChakraCore engine, on top of the integration with Node that Microsoft created in [Node.js on ChakraCore](https://github.com/nodejs/node-chakracore). ChakraCore has a well-optimized, pure interpreter mode which complies with iOS' restrictions.

On both platforms, the result is a runtime that ensures the highest level of compatibility with Node.js.

### Built for the community

At Janea Systems, we love Node.js. We have been involved with the project and its community for many years. We have been contributing to the Windows version since its early days, and have been participating in several committees, working groups and efforts at the Node.js Foundation.

With this project, we wanted to create a space where we can experiment and quickly iterate on the features that are specifically needed for Node.js as a building block for mobile applications. So, while this is technically a fork on GitHub, it is absolutely not in our intention to divide the Node.js community or antagonize the Node.js project. On the contrary, we hope that this effort will help Node.js become even stronger and more ubiquitous.

We anticipate that developers will build amazing things with these tools, far beyond what we can imagine today. So we invite you to get involved. Try the toolkit. Provide feedback, report bugs, suggest improvements, contribute code. Go build amazing new apps and radically new frameworks with it!

We can’t wait to see what you will come up with. And we look forward to working with the community towards making mobile app development more accessible, productive and fun.

To get started, visit the [Node.js for Mobile Apps website](https://code.janeasystems.com/nodejs-mobile).

large_nodejs-mobile-1024x512.jpg

medium_nodejs-mobile-1024x512.jpg

small_nodejs-mobile-1024x512.jpg

thumbnail_nodejs-mobile-1024x512.jpg

nodejs-mobile-1024x512.jpg

Announcing Node.js for Mobile Apps: a full-fledged Node.js runtime for Android and iOS

Developer Blogs

At Janea Systems, recruitment goes beyond just filling positions; it’s about weaving together a community of the industry’s finest minds committed to engineering excellence. Rooted in a legacy of elite software engineering, we hire individuals who excel in coding and are passionate about crafting solutions that leave a lasting impact. Our recruitment process consists of three stages designed meticulously to identify and nurture standout talent.

We understand that recruitment isn’t one-sided. Yes, interviews are a way for us to vet the best and brightest in the industry, but they’re also a way for you to see if you’d enjoy working here, too.

## Our talent selection philosophy

In the fast-paced world of software engineering, the ability to rapidly learn and adapt is paramount. At Janea Systems, we understand that the field is constantly evolving, and staying ahead means embracing continuous learning. That’s why, rather than focusing solely on specific knowledge, we prioritize the capacity for rapid learning and adaptation in our engineers. Our technical interviews are tailored to this philosophy, featuring questions that challenge candidates to solve unfamiliar problems rather than just testing their knowledge of language constructs and libraries.

Adaptability and a proactive mindset are at the heart of what we look for in our team members. We value individuals who are not only skilled problem solvers but also those who demonstrate a high level of adaptability and a can-do attitude, crucial qualities for driving our clients’ mission-critical software engineering initiatives.  
Collaboration and communication are key components of our culture at Janea Systems. We seek engineers who are passionate about their work and thrive in a collaborative environment. Our culture celebrates teamwork, encouraging each member to contribute their unique skills and perspectives.

Our philosophy ensures that our team is equipped to handle today’s challenges and prepared to lead tomorrow’s innovations. Our approach is a testament to our commitment to excellence, fostering a culture where exceptional talent thrives and innovation is a daily pursuit.

## Janea Systems Interview Rounds

Before advancing to the offer conversation and, hopefully, joining our award-winning team of elite engineers, there are three stages of interviews: 

![Janea-Recruitment-Process-Blog-1024x536.jpg](https://cloud-cube-us2.s3.amazonaws.com/nqnr0sjjo9vs/public/Janea_Recruitment_Process_Blog_1024x536_0f0925baa9.jpg)

We’ll take you through each below, explain why they’re important, and give you some tips from engineers who have been through the process themselves and made it out the other side (don’t worry, it’s not that bad).  

### **Stage 1: The Online Coding Challenge**

The Online Coding Challenge lasts around an hour and aims to gauge your ability to solve a problem using the coding language you specialize in. You’ll be tasked with coding a general solution that can handle any input within the given constraints. Authored by our engineers, it’s a pass-or-fail evaluation, with the testing platform automatically assessing your answer. 

#### Why It’s Important

This stage is crucial as it lays the groundwork for evaluating your technical skills and problem-solving ability within your area of expertise. 

#### Tips for Acing the Online Coding Challenge

A thorough understanding of coding principles within your chosen language and getting accustomed to common coding challenges will steer you through this stage effectively. These [preparation tests](https://www.hackerrank.com/dashboard) are a good place to start. 

### Stage 2: Recruiter Interview

At this stage, you’ll be invited to a conversation, lasting no longer than an hour, with a member of our recruitment team to delve into your previous experiences. This interview also provides an opportunity to learn more about who we are, what we stand for, and how we work as a company. 

#### Why It’s Important

This conversation is a two-way street. We get to learn more about you, and you get a glimpse into Janea Systems’ culture, laying the groundwork for a potentially great fit. 

#### Preparing for Success

It should go without saying, but read the job description. Try to align your experience with the job description. Also, having a clear narrative about your professional experience and a couple of questions about Janea Systems can lead to a better discussion.  

### Stage 3: Technical Interview

You’ve made it through the Online Coding Challenge, so you’ve shown some programming and problem-solving competency. You’ve made it through the Recruiter Interview, so we think you’re a good fit for the company. The final hurdle is a 2-hour Technical Interview, a deep dive into your technical and collaborative abilities. 

The 2-hour lab coding interview is designed to be dynamic and engaging. We start with a couple of logic problems. These are not just warm-up exercises but also an opportunity for us to understand your approach to problem-solving and logical thinking. 

Following the initial logic problems, we dive into a live coding challenge. As per our commitment to flexibility, you can choose any programming language you are comfortable with for this part of the interview. This approach allows us to see you in your element, using the tools you know best, which is crucial for a fair and effective assessment. The technical interview gives us insight into not only your coding skills but also how you approach problems and iterate on your solutions. It’s also a chance for us to see how you work under a bit of pressure and how you manage time and resources. 

Great engineering is as much about working well with others as it is about technical expertise. We’ll be looking at how you communicate your ideas, respond to feedback, and adapt to new information or challenges. 

#### Why It’s Important

This intensive evaluation goes beyond mere coding. It embodies Janea Systems’ philosophy of holistic problem-solving paired with robust collaboration. Our approach to software engineering isn’t just about code but revolves around critical thinking, effective collaboration, and delivering impactful solutions. 

#### Tips from our Technical Interviewers

1.  **Don’t Rely on IDEs:** You won’t have access to an Integrated Development Environment (IDE). Expect to code without the aid of auto-suggestions or syntax help. This format aims to gauge your ability to think and code without external aids. 
2.  **We’re Looking for Expressive Coding:** Our primary focus isn’t to test your memory of syntax. We’re keen on seeing how you translate a coherent thought process into functional code. The objective isn’t specific knowledge but an expressive representation of your solution. 
3.  **We’re Assessing Critical Thinking:** It’s not just about coding. It’s about aligning your solution with the company’s goals, project requirements, and client needs. Demonstrating a capacity to evaluate situations and pivot your solutions accordingly critically is paramount. 
4.  **Understand the Problem Before Coding:** A common pitfall many candidates stumble into is jumping directly into coding. Taking a moment to comprehend the problem fully can be the difference between a practical solution and a convoluted one. 
5.  **Respond to Feedback**: During the interview, you may receive feedback. Ignoring it can be detrimental. If the interviewer offers a direction or perspective, it’s worth considering. 
6.  **Simplicity Over Complexity:** A crucial tip to remember is the essence of simplicity. Given the time constraints, our problems are designed to be succinct. Overcomplicating solutions or attempting to draft extensive code might not be the best strategy (we’re not expecting 500 lines of code in 2 hours). 
7.  **Get a good night’s sleep before the interview.**

Displaying a balanced blend of technical knowledge, clear communication, and a pragmatic approach to problem-solving will ensure you’re on the way to joining the ranks of Janea Systems’ software engineering team. 

Understanding that each engineer has unique strengths, we try to be as flexible in the interview process as we are in our work. Choices, such as allowing you to pick which programming language in your technical interview, are not just about accommodating your preferences; it’s about seeing you at your best and most confident. It’s an opportunity for us to see how you apply your skills to an unfamiliar challenge in a familiar context. We believe this is crucial for a genuine assessment of your capabilities.

Adapting to various challenges and environments indicates how you will thrive while working on our diverse and ever-evolving projects. It’s these qualities that define our team at Janea Systems and enable us to consistently deliver excellence on projects that impact millions of developers and billions of people every day.

## Resources to Help You Prepare

[Daily Coding Problem](https://www.dailycodingproblem.com/) 

[Practice for Cracking Any Coding Interview](https://www.geeksforgeeks.org/practice-for-cracking-any-coding-interview/)

[The Myth and Reality of the 10X Engineer](https://www.janeasystems.com/blog/the-myth-and-reality-of-the-10x-engineer/)

## Conclusion

At Janea Systems, we’re thrilled to have brilliant minds like yours contribute to our mission of delivering unparalleled software solutions. If you’re ready to embark on a fulfilling career in software engineering, [check out our open positions here.](https://www.janeasystems.com/current-openings/)

Good luck in your interviews!

large_Janea-Recruitment-Process-Blog-1024x536.jpg

medium_Janea-Recruitment-Process-Blog-1024x536.jpg

small_Janea-Recruitment-Process-Blog-1024x536.jpg

thumbnail_Janea-Recruitment-Process-Blog-1024x536.jpg

Janea-Recruitment-Process-Blog-1024x536.jpg

The Janea Systems Recruitment Process

In the ever-evolving domain of enterprise open-source software (OSS), our team takes pride in being trusted to maintain a variety of pivotal projects. From enhancing libraries like [PyTorch, Node.js](https://www.janeasystems.com/blog/unlocking-the-power-of-open-source-lessons-from-janeas-seasoned-developers/), and [React Native](https://www.janeasystems.com/blog/janea-systems-helps-unblock-key-microsoft-customers-utilizing-react-native-for-windows/) for seamless cross-platform performance to building and maintaining award-winning tools like Microsoft PowerToys, our collaborative efforts highlight the collective power of open source. As we delve into our top tips for enterprise OSS project maintenance, we draw from over two decades of experience, sharing insights to help both seasoned maintainers and those just starting their open source journey.

Read on to discover how our global team of top software engineering open source advocates navigate the complexities of enterprise OSS, shaping the future of technology with every commit.

## 1\. Meticulous Merges – Understand Every Line of Code

João Reis emphasizes: "Understand every line." Before integrating changes, it's crucial to rigorously assess the implications of pull requests. Every merge has a ripple effect – from developers to end-users. In the realm of open-source, hasty merges can be costly. What you gain in time, you may pay for with your reputation and the need for follow-up fixes. Prioritize accuracy over speed, and remember that in the open-source ecosystem, our mistakes are communal, but so are our triumphs.

## 2\. Priority and Expectation Management – Master the Art of Triage

Jaime Bernardo on navigating a bustling project landscape: "Master the Art of Triage." Managing an enterprise open-source project is a balancing act between client deliverables and the vibrant unpredictability of community contributions.  
The phenomenal performance of PowerToys in 2022 — hitting 3rd place for first-time contributor count and 5th for total contributors, as well as being the 2nd fastest-growing open-source project on GitHub — showcases this balance in action. It's about embracing the unexpected while steadfastly adhering to your project roadmap. "It's essential to discern what demands immediate action and what aligns with long-term objectives. Each task, whether it's an anticipated bug fix or a surprising new feature suggested by a first-time contributor, must be weighed and prioritized to foster growth without derailing the project's course."

## 3\. Community Engagement – Be the Welcome Sign

João Reis advises: "Be the welcome sign." Open source is as much about the code as the community. "Extend a hand, be accessible, and foster a nurturing environment. Your guidance today could empower the lead maintainers of tomorrow. Remember, every expert was once a novice."

## 4\. Cross-Platform Consideration – Think Ecosystems, Not Just Features

João Reis on maintaining a holistic view: "Think ecosystem, not just features." In a multi-platform world, ensure that solutions are inclusive of diverse environments. “Each merge should be a step towards unity, not divergence, across platforms. The strength of your project lies in its universal operability, not just its individual features.”

## 5\. Pace and Patience – Speed isn't Everything

Stefan Markovic shares a pragmatic reminder: "Speed isn't everything. In the open-source world, especially in projects with thousands of contributors like ours, rapid movement isn't always a sign of healthy progress. It's important not to rush. True, things can progress slowly, but the best solutions are often those that are given time to mature. Patience is not just a virtue; it's a necessity for sustainable development.”

[Get in contact here](https://www.janeasystems.com/#lets-talk) to find out how we can support your open source initiatives.

---

## More about our software engineers:

### Joao Reis – Lead Software Engineer

One of the first employees at Janea Systems, Joao has worked on maintaining the Windows version of Node.js, including the development and maintenance of the Windows CI system in close collaboration with the open source community. João also worked on several cloud-agnostic projects, giving him deep experience and the ability to work across the board, from embedded to massive web applications.

### Jaime Bernardo – Lead Software Engineer

Jaime’s project work for Janea Systems covers many areas, including porting Node.js to Android and iOS, porting react-native modules to Windows, and developing/actively maintaining Microsoft PowerToys to this day, among other projects.

### Stefan Markovic – Lead Software Engineer

Stefan's professional journey began with a local outsourcing company where he specialized in developing and maintaining GNU tools, primarily utilizing the C programming language. After gaining valuable experience there, he transitioned to TomTom, where he worked on developing navigation software systems, with a focus on the routing engine using C++ language. He now works closely with Jaime, actively maintaining the award-winning Microsoft PowerToys project.

large_Top Tips Open Source Header Image (2).png

medium_Top Tips Open Source Header Image (2).png

small_Top Tips Open Source Header Image (2).png

thumbnail_Top Tips Open Source Header Image (2).png

Top Tips Open Source Header Image (2).png

5 Top Tips for Maintaining Enterprise Open Source Projects 

AI/ML

Today, the narrative around Artificial Intelligence (AI) is often driven by the bells and whistles of futuristic technologies. Think robodogs, AI chatbots, and the like. But AI isn't new. It's far-reaching yet often out of sight, transforming the everyday tools and platforms we interact with. To illustrate this, we're sharing how Janea Systems contributed to three critical AI projects: PyTorch, Query Annotation Service (QAS), and Bing Spatial Data Services. They're not quite as entertaining as a robot doing a backflip, but they're definitely more useful.   

## Bing QAS: Optimizing Search Engine Accuracy 

The Query Annotation Service (QAS) is integral to search engines, processing user inputs to identify the physical locations and entities users seek. As fundamental as it is, QAS had room for improvement, particularly in the accuracy of its geolocation results. 

With our deep understanding of complex back-end systems, we were tasked to refine QAS and minimize these errors. Using various technologies, including C++, Python, and PowerShell scripting, we developed a script capable of batch-uploading query errors to an internal database. We created a refinement pipeline with smart features to notify stakeholders of any issues. The result? An improved QAS, powering multiple systems that rely on Bing geocoding. 

## Bing Spatial Data Services: Refining Geocoding 

Bing Spatial Data Services play a pivotal role in geocoding - converting addresses into geographic coordinates. Janea Systems has been actively involved in maintaining and updating these services, contributing to three complex AI codebases: Bing Geocoding, the Bing Location & Understanding (BLU) Infrastructure Back-End, and the transition from the Extensible Application Platform (XAP) to Azure – the infrastructure for holding AI-based and general applications. 

In the process, we've cleaned up the codebase, improved performance, modularized, and modernized the system to accelerate feature development and enable faster iteration on future proof of concepts (POCs). Our work has improved Bing's geocoding services' efficiency and helped uphold coding engineering guidelines, standards, and naming conventions. 

## PyTorch: Democratizing Machine Learning 

PyTorch, developed by Facebook's AI Research (FAIR) team, is an open-source machine learning library that plays a crucial role in fields like computer vision and natural language processing. Since its release in 2016, companies like OpenAI have adopted it extensively for various applications. 

Despite its capabilities, PyTorch faced challenges related to compatibility and accessibility. Leveraging our system-level expertise, we ensure a stable version of PyTorch for Windows, enabling users to take advantage of new features introduced to C++17. We also contribute to the ongoing effort to port the library to run on Windows on devices with Arm-based processors.   

We embarked on an extensive improvement process using a blend of technologies such as Python, C#, Arm64 architecture, Linux, the Gloo project, Continuous Integration (CI) tools, and .NET. Our team resolved Windows-specific CI test failures, assisted in transitioning PyTorch to C++17, implemented fixes in the Gloo project, and contributed to TorchSharp, extending the PyTorch API to the .NET ecosystem. These improvements have democratized access to PyTorch and reinforced its position as a go-to library for Machine Learning and Deep Learning, enabling the groundbreaking AI projects in the news today and in the future. 

## Conclusion 

Before it even started making things, AI was a ubiquitous force, and these three examples provide a glimpse into the critical but often unseen roles that AI plays in our everyday interactions with digital technologies. As we continue to expand our AI practice with exciting projects and initiatives (such as our newest AI safety venture, BigFilter.ai), we remain committed to pushing the boundaries of AI, ML, and software engineering to create a better digital world.   

Get in touch to find out more about our AI practice [here](https://www.janeasystems.com/#lets-talk).

large_3-examples-Everyday-AI-blog-v1.png

medium_3-examples-Everyday-AI-blog-v1.png

small_3-examples-Everyday-AI-blog-v1.png

thumbnail_3-examples-Everyday-AI-blog-v1.png

3-examples-Everyday-AI-blog-v1.png

3 Examples of Boring AI that Power Our Everyday Lives: A Closer Look with Janea Systems 

large_AI Blog Cover smll.jpg

medium_AI Blog Cover smll.jpg

small_AI Blog Cover smll.jpg

thumbnail_AI Blog Cover smll.jpg

AI Blog Cover smll.jpg

March of the Machines: Last Month in AI

## A brief history of open source  

In the 1950s, when academics and corporate researchers were the primary producers of computer software and compilers, most software came free with hardware purchases. Much of the software from this era was shared as public-domain software, i.e., software with no ownership. Towards the 70s, as OSs and programming languages evolved, it was clear that bundling software with hardware for free was not financially viable. Software providers had no incentive to maintain programs as they weren't getting paid for it.    

In 1974 software was legally considered copyrightable, and over the next decade, companies charging for software became the new norm. As large-scale operating systems matured, fewer organizations allowed modifications, and eventually, operating systems became closed to modification. By the 80s, companies were no longer distributing source code with products. Despite this shift towards closed-source software, open source (or free software) advocates used alternative means to share their source code freely with other programmers and users, such as computer magazines and bulletin board systems.   

In 1983, the same year Apple won a lawsuit clarifying that a program's source code and binary code were covered by copyright, Richard Stallman launched the free software movement. Motivated by incidents where the lack of access to source code prevented users from fixing software problems, Stallman initiated the GNU Project intending to create a complete operating system free from constraints on using its source code. In 1989, the GNU General Public License was published, providing a legal framework for software's unrestricted use, modification, and distribution.   

A couple of years later, in 1991, we saw the birth of arguably the most significant open source project to date, the Linux kernel, released under the GNU General Public License. Today, this massive collaborative project powers 85% of all smartphones, it's used by major space programs such as those of SpaceX and NASA, and the kernel ran on all of the world's 500 supercomputers in 2021.  

Although 90% of companies are now using open source, the movement has democratized creating, using, and sharing software for everyone. This blog delves into the importance of open source, featuring insights from seasoned developers with first-hand experience working on some of the world's most significant open source projects.  

## What is Open Source?  

Open source refers to software with publicly accessible source code. It allows developers to build on top of software, reverse engineer it, and repurpose it however they see fit. Anyone can inspect, modify, or distribute the software's source code, encouraging collaboration, transparency and fostering a developer community. Today, dozens of open source licenses exist with varying terms and conditions for modifying and distributing modified works. Some allow users to take open source code to be edited and used in commercial, closed source settings. Others ensure that open source stays open. The rise of Open Source projects has enabled the success of platforms like GitHub, where developers worldwide contribute to thousands of projects every day.  

## Advantages of Open Source 

Open source continues to revolutionize software development. It empowers organizations and individuals to tailor software to meet specific needs. It's a much more cost-effective solution to developing closed source software because it avoids vendor lock-ins and costly license fees. It also stimulates rapid innovation from a large developer community, increasing the quality of software, the number of features, and its security because it is constantly under review. Open source also bolsters interoperability, often being compatible with other open source and proprietary software. It fosters community, creating robust support networks, forums, and resources for troubleshooting and learning. With all of this, it creates a higher level of trust. Users can verify what the software is doing instead of relying on vendor assurances.  

## Janea Systems' Experience with Open Source  

Here at Janea, we have over 18 years of experience working on open source projects and even more tinkering in our spare time. Across Janea's portfolio of ventures, our diverse team of open source advocates work across several operating systems and hardware setups. It's because of this that we know, all too well, the annoyance of system incompatibility, and it's one of the primary reasons why a lot of our open source work revolves around interoperability. Our open source work ensures developers can utilize systems and programs in settings that feel native to them, whatever their setup.  

![](https://www.janeasystems.com/wp-content/uploads/2023/07/Alexis-MacBook-ThinkPad.png)

Our Founder and Chairman of the Board, Alexis Campailla, stuck a ThinkPad keyboard on a MacBook Air.   

## Different Types of Open Source Projects

> > "Essentially, there are two kinds of open source projects.   
> > 
> > (1.)Projects started in the community, driven by people who want to build and share code online altruistically.
> > 
> > (2.) Then you have open source projects from companies. These projects could be closed source, but being open source is mutually beneficial for the open source community and the company because it gives anyone access to the software, and companies get help to support more features."   
> > 
> > _João Reis, Lead Software Engineer at Janea Systems_

Take a look at just a few of the open source projects we've worked on and what our developers have had to say about them.  

## [PyTorch](https://github.com/JaneaSystems/pytorch)  

Our ongoing work enables developers and data scientists to utilize PyTorch to its full potential across the Windows ecosystem. Our team is trusted to maintain PyTorch for the Windows open source community. This work includes ensuring stability by resolving PyTorch Continuous Integration (CI) test failures, actively contributing to TorchSharp - an initiative aimed at extending the PyTorch API to the .NET ecosystem, and transitioning PyTorch to C++17 which our Lead Engineer, João Reis, describes below:  

> "One piece of work from this project that we're really proud of was enabling C++17 on PyTorch. This was blocked on Windows because of a few issues, but we reviewed them, fixed them, and helped move it forward. Now PyTorch is coded in C++17 to keep up with the C++ standard, essentially modernizing the code base."  

## [React Native](https://github.com/orgs/JaneaSystems/repositories?q=react-native&type=all&language=&sort=)

Our work on React Native provided a unified developer experience across the Windows ecosystem, enabling devs to create Windows desktop applications. While React Native successfully served iOS and Android developers, there was a significant gap for the Windows user base. Several mobile platform modules were unavailable on Windows, which hindered the development process. Our work porting 16 core modules was significant to many Microsoft clients and the broader developer community.  

Jaime sums up the project here: 

> "Native modules allow you to access information specific to the device. Let's say you want to access photos or get information on what OS the hardware is running or the available Ram on mobile. You don't get access to any of that when you're just doing an application with JavaScript and HTML because it's supposed to run in a browser. But these are native desktop apps, so for each platform, there needs to be some code that accesses this information. This was already in place for iOS and Android. Our work on this project helped bring this functionality to Windows so that people could pick up the web apps they've done in iOS and Android and port them easily to also work on Windows, using their original React Native code."  

## [PowerToys](https://github.com/microsoft/PowerToys)  

We were trusted to develop the core feature set of the recently reinvented Microsoft PowerToys. This includes utilities such as Color Picker, FancyZones, Video Conference Mute (Experimental), File Explorer Addons, Image Resizer, PowerToys Run, Keyboard Manager, Shortcut Guide, and PowerRename.  

Jaime tells us about a problem the team overcame while working on FancyZones:  

"One specific challenge we faced was with a particular set of screens or monitors. Screen manufacturers should set a unique string that identifies the screen, but one set of monitors would send the same ID for that model on every screen. So, there was no way for us to see which screen was which. This was especially problematic working on modules like Fancy Zones. We had to implement and iterate on many strategies to ensure the zones wouldn't reset when, for example, people disconnect and reconnected screens, or when they restarted a computer or went to their lock screens."  

This is just one small example of the diverse set of problems our team must overcome while working on open source projects. We're particularly proud of our work on this project and the great reception from the open source community. [GitHub’s 2022 State of Open Source report](https://octoverse.github.com/) ranked PowerToys: 

*   2nd place for open source projects with the highest contributor growth 
*   3rd place for top open source projects by first-time contributor count 
*   5th place for top open source projects by contributors as a whole  

## Challenges in Open Source Projects  

When working on open source projects, no two days are the same. With anyone being able to contribute, there's always something new to work on, but this also poses challenges.   

One difficulty with open source projects is learning new frameworks and working methods. For example, our work on react native covered 16 diverse modules from text to speech systems to media player functionality. This keeps our developers on their toes because they must have an intricate understanding of a module to successfully work on it. Our developers see this as a challenge and an opportunity as every new codebase endeavors to expand on their deep tech-agnostic expertise.  

When working for a company on open source, multiple stakeholders are often involved at varying levels. Some programs are owned by one company but maintained by another for specific OSs and hardware. In addition, the open source community is a significant stakeholder in projects. Prioritizing and juggling requirements can sometimes prove difficult, but we've managed to overcome this over the years by ensuring clear communication with all stakeholders and holding ourselves accountable.  

Much of our work revolves around solving incredibly complex software engineering challenges. More significant bugs must be solved quickly to ensure that the program works for most users but "minor" issues can sometimes be left by the wayside, especially when it comes to edge cases with unique hardware setups. One of the challenges we face in this work is being unable to replicate and troubleshoot bugs because of the hardware setups.  

## Conclusion  

Open source allows us to harness collective intelligence for exponential innovation. Here at Janea, embracing open source affirms our commitment to transparency, collaboration and inclusiveness while enabling developers of all skill sets to thrive.  

Open source encourages us to transcend the traditional silos of knowledge, inviting us into a global workshop where collaboration, creativity, and transparency lead. We firmly believe that no matter how smart the people you hire inside your company, there are always smarter people outside. That's why we're committed to open source and will continue to contribute to it, absorb its lessons, and help shape our collective digital future with it.  

Get in contact with us to find out more about our open source work.

large_wallpaperflare.com_wallpaper(1).jpg

medium_wallpaperflare.com_wallpaper(1).jpg

small_wallpaperflare.com_wallpaper(1).jpg

thumbnail_wallpaperflare.com_wallpaper(1).jpg

wallpaperflare.com_wallpaper(1).jpg

 Unlocking the Power of Open Source: Lessons from Janea's Seasoned Developers

Janea Systems continues to bring world-class software engineering to developers and enterprise companies across the globe. Now, we’re ready to launch the world's most advanced Redis-compatible cache and datastore for Windows. It’s called **Memurai**.

Developers know all too well that the frustrating search for a supported, up-to-date Windows build of Redis always ends with little more than a complicated and inefficient workaround. No more. Memurai puts an end to non-native solutions that fail to fully integrate the world’s most popular NoSQL datastore into their Windows infrastructure.

### **SEAMLESS AND WINDOWS-NATIVE**

Memurai is fully Windows-native and compatible with Redis, with performance and reliability that developers need and demand. It’s fast, flexible, and fine-tuned for optimal performance.

With Memurai, you won’t miss any functionality since its core is based on Redis source code. That means developers will still have access to the features that make Redis such a popular and helpful cache/datastore.

Memurai is a game changer. Engineering teams with long-term investments in Windows infrastructure will be able to get up to speed with Memurai quickly. Huge datasets and mission-critical workloads are safe and sound within Memurai.

Memurai is scalable, supported, and reliable. It’s the only Redis-compatible cache/datastore for Windows anyone will ever need.

### **PACKED WITH POPULAR FEATURES**

Memurai supports all of Redis’ most popular features, including:

* Persistence
* Replication
* Transactions
* LUA scripting
* Modules
* Streams
* API 5 eviction policies

### **JANEA SYSTEMS AND MEMURAI**

At Janea Systems, we love Redis, too. In fact, we helped write the archived (no longer supported) official Microsoft Open Tech port of Redis. However, we knew of the need for a Redis-compatible cache and datastore for Windows, so we created one.

We think you’ll love Memurai, and we’ve made installation super easy. Remember: If you’re already running Redis on Linux, you can simply replicate the data between Memurai and Redis — or use them both within the same cluster.

![](http://www.janeasystems.com/wp-content/uploads/2019/08/memurai_comparisons-1024x404.jpg)

[**\>>>READY TO TRY MEMURAI? DOWNLOAD IT FOR FREE!\<\<\<**](https://www.memurai.com/)

large_Memurai_via_Janea-Systems_Memurai-1-1024x256.png

medium_Memurai_via_Janea-Systems_Memurai-1-1024x256.png

small_Memurai_via_Janea-Systems_Memurai-1-1024x256.png

thumbnail_Memurai_via_Janea-Systems_Memurai-1-1024x256.png

Memurai_via_Janea-Systems_Memurai-1-1024x256.png

Say Hello To Memurai: A Redis-Compatible Cache And Datastore For Windows

large_Janea Systems OG Image No Text.png

medium_Janea Systems OG Image No Text.png

small_Janea Systems OG Image No Text.png

thumbnail_Janea Systems OG Image No Text.png

Janea Systems OG Image No Text.png

Janea Systems is a software engineering consultancy, serving the enterprises that drive global innovation for over two decades. We help our clients build and optimize technologies used by millions of developers and billions of consumers. 

Solving the Most Complex Software Engineering Problems

Blogs

Let's talk about your project

Let's talk about your project