The integration of Large Language Models (LLMs) into software development workflows has become inevitable, making it essential that computer science educators prepare students to use these tools effectively and responsibly. Recent research shows that LLMs are capable of solving the majority of assignments and exams previously used in CS1, and professional software engineers are increasingly using these tools, raising questions about whether we should be training students in their use.

Rather than viewing LLMs as threats to traditional programming education, we should embrace a structured pedagogical approach that develops students’ ability to work productively with AI tools while maintaining their problem-solving skills and critical thinking abilities.

A Three-Stage Developmental Framework

Based on emerging educational research, pedagogical best practices, and my own experience using AIs for software engineering, I propose a three-stage progression that reflects both cognitive development and increasing technical sophistication:

Stage 1: AI as Consultant (Foundational Level)

Pedagogical Goals:

• Develop effective question formulation skills
• Build critical evaluation capabilities
• Learn to iterate and refine queries
• Understand LLM limitations and biases

Learning Activities: Students interact with LLMs primarily through chat interfaces (ChatGPT, Claude, etc.) for research and problem-solving support. Research suggests that providing structured guidance, such as explicit instructions or prompting students to first attempt problems independently before refining solutions with LLM assistance, can reduce unproductive queries and enhance student engagement.

Essential Skills to Teach:

• Problem Decomposition: Before querying the LLM, students must define their problem, attempt a solution, and identify specific roadblocks
• Critical Evaluation: Implement the “5 whys” technique – repeatedly asking “why is this the best approach?” to validate AI responses
• Source Validation: Cross-reference AI responses with official documentation and trusted sources

Assessment Strategies:

• Query portfolios showing progression from vague to specific questions
• Reflection essays on when AI provided helpful vs. misleading information
• Compare-and-contrast exercises between AI responses and authoritative sources

Stage 2: AI as Programming Partner (Intermediate Level)

Pedagogical Goals:

• Understand code completion and suggestion systems
• Develop prompt engineering skills for code generation
• Learn to read, modify, and debug AI-generated code
• Build habits of testing and verification

Learning Activities: Students work with embedded IDE tools (GitHub Copilot, Continue, etc.) that provide real-time coding assistance. This approach allows students to focus on problem-solving and algorithms while relying on automatic code generation for implementation details.

Essential Skills to Teach:

• Contextual Prompting: Writing meaningful comments and function signatures that guide AI completion
• Code Review Skills: Systematically reading and understanding AI-generated code
• Testing Mindset: Always creating test cases to verify AI-generated solutions
• Incremental Development: Using AI for small, well-defined tasks rather than complete solutions

Scaffolding Techniques: Research on “learner-LLM co-decomposition” suggests that interactive systems that scaffold learners’ personalized construction of solution steps provide more effective learning than generic assistance. Implement:

• Structured templates for common programming patterns
• Checkpoint reviews where students explain AI-generated code
• Peer programming sessions combining human creativity with AI efficiency

Stage 3: AI as Development Team Member (Advanced Level)

Pedagogical Goals:

• Manage complex, multi-step development tasks
• Coordinate AI assistance within professional workflows
• Apply software engineering best practices to AI-assisted development
• Develop leadership and delegation skills

Learning Activities: Students use advanced AI coding agents (Claude Artifacts, GitHub Copilot Workspace) to complete substantial projects while maintaining oversight and quality control.

Essential Skills to Teach:

• Requirements Definition: Creating clear, testable specifications for AI systems
• Code Review and Quality Assurance: Implementing systematic review processes
• Documentation and Maintainability: Ensuring AI-generated code meets professional standards
• Security Awareness: Analyzing and interpreting generated code for potential security vulnerabilities
• Project Management: Breaking large tasks into manageable, AI-appropriate subtasks

Pedagogical Considerations Across All Stages

Avoiding Over-Reliance

Studies have found that students who use LLMs for assignments performed better on those problems but worse on overall assessments, with excessive dependence impairing essential independent problem-solving skills. To prevent this:

• Require AI-free coding exercises and assessments
• Implement “explain your reasoning” requirements for AI-assisted work
• Create assignments that require creative problem-solving beyond AI capabilities

Scaffolding Learning Progression

LLMs can serve as scaffolding strategies throughout the problem-solving process, helping clarify goals, facilitate higher-level cognitive activity, and promote continuous improvement through guided reflection. Effective scaffolding includes:

• Structured Progression: Move from highly guided to increasingly independent use
• Metacognitive Reflection: Regular discussions about when and why to use AI assistance
• Error Analysis: Studying and learning from AI mistakes and limitations

Assessment Adaptation

Traditional assessment methods may need revision:

• Process-Focused Evaluation: Assess problem-solving approach, not just final code
• Collaborative Assessment: Evaluate human-AI teamwork effectiveness
• Transfer Testing: Ensure students can work independently when AI is unavailable

Ethical Considerations

Address challenges around academic integrity while upholding the goal of developing competent, ethical software professionals:

• Clear policies on appropriate AI use in different contexts
• Discussion of professional ethics and AI tool limitations
• Training in attribution and intellectual property considerations

Implementation Recommendations

1. Start with Fundamentals: Ensure students have basic programming competency before introducing AI tools
2. Progressive Complexity: Move through stages systematically, not skipping developmental steps
3. Regular Calibration: Frequently assess whether students maintain independent problem-solving abilities
4. Professional Context: Connect each stage to real-world software development practices
5. Continuous Adaptation: As purpose-built educational AI systems become more sophisticated and aligned with learning science principles, adjust approaches accordingly

This framework acknowledges that LLMs capable of generating accurate source code from natural-language prompts are likely to improve professional developer productivity while ensuring that students develop both the technical skills and critical thinking abilities necessary for effective human-AI collaboration in their careers.

By implementing this structured approach, CS educators can prepare students not just to use AI tools, but to use them thoughtfully, effectively, and ethically throughout their professional development.

The post A Pedagogical Framework for Teaching Effective LLM Use in Programming Education appeared first on Mike Lynch.

Introduction to Game-Based Economies

Game-based economies are increasingly being integrated into various projects as a tool to drive user engagement and motivate desired user behaviors. These systems, largely centered around gamification, aim to encourage users to achieve specific outcomes through structured incentives. While this approach has found robust applications in sectors learning, it’s essential to contemplate whether it’s the right choice for your project, as it carries both advantages and potential pitfalls.

In the context of learning, gamification serves as a powerful motivator. It can significantly enhance user engagement by appealing to innate desires for achievement and recognition. However, it’s crucial to remember that with great power comes great responsibility. Gamification isn’t a universal solution and can sometimes lead users to prioritize the game-like aspects over the actual learning objectives. This distraction can manifest when users focus excessively on earning points or rewards, potentially undermining the primary goal of fostering genuine understanding or skill development.

Particularly in educational settings, this approach works best when learners are inherently inclined to engage with the material, we call this internally motivated. For adult learners, this can be beneficial as they are typically more conscious of gamification strategies and align these external motivations with their internal goals. They acknowledge the gamified elements as tools to enhance their learning journey, rather than the end goal.

However, the dynamic shifts with younger users, who may not yet possess the internal drive to engage deeply with the content. In such cases, gamification can lead to surface-level engagement, where the focus shifts from meaningful learning to merely gaming the system—achieving the rewards without achieving the actual learning outcomes.

I can’t stress enough how perilous this can be for a learning application. Consider the scenario where you’ve poured your heart and soul into crafting an exceptional educational product. You launch it with high hopes and initially see fantastic levels of user engagement. Your community seems to be thriving, and your mission to foster learning and growth feels within reach—except, here’s the catch. If your users end up simply mastering the art of exploiting the point system instead of truly learning, then all that effort amounts to little more than squandering both their time and your resources. In a free-to-use model, you’ll witness users frittering away precious hours, while you’re left to bear the financial burden. In a subscription-based model, it may seem like a financial success, but picture the disappointed parents who have entrusted you with their children’s education, only to find that their investment is yielding hollow results. You owe it to them—and yourself—to ensure that this tool empowers genuine learning, not just savvy navigation of a game.

Ultimately, while a game-based economy can be a valuable tool to increase activity and engagement, it should be carefully implemented with a clear focus on genuine objectives rather than on the mechanics of the game itself. Balancing gamified elements with the core mission of your platform is crucial to ensure that these strategies facilitate rather than distract from the intended outcomes.

Taxonomy of a game-based economy

Let’s begin with an overview of the elements found in game-based systems.

Game-based currency

Game-based currency serves as the central pillar of gamified systems, transforming user engagement into quantifiable rewards that drive interaction and motivation. These currencies, whether they take the form of points, badges, or virtual tokens, act as tools to incentivize users to participate in activities that align with the platform’s goals. By offering tangible metrics for achievement, game-based currencies tap into the intrinsic desire for accomplishment and recognition, encouraging users to engage more deeply and frequently. This digital economy not only enhances the user experience by providing a sense of progression and purpose but also fosters a dynamic community that thrives on active participation and shared success. As we explore the different types of game-based currency, it’s essential to understand how these tools can be tailored to fit the unique needs and objectives of any interactive platform.

1. Reputation Points:

• Earning Points: Users can earn points by asking good questions, providing helpful answers, upvoting, receiving upvotes, and other community engagement.
• Spending Points: Allow users to spend points on certain privileges or community features, such as promoting questions, highlighting posts, or unlocking certain content.

2. Badges and Achievements:

• Diverse Badges: Create badges for different activities, such as answering the first question, receiving a certain number of upvotes, or contributing for several consecutive days.
• Tiered Achievements: Offer levels within badges for continued achievement, creating a tiered system that encourages long-term engagement.

3. Virtual Currency:

• Introduction of a Currency System: Implement a system where points translate into a virtual currency that can be used for various site features, such as unlocking premium content, customizing the user profile, or accessing advanced tools.
• Purchases and Investments: Allow users to use currency to invest in other users’ questions or projects, with potential returns based on the popularity or impact of those projects.

4. Leaderboard Rankings:

• Global and Topic-Based Leaderboards: Display rankings globally and within specific topics to encourage competition and specialization.
• Weekly/Monthly Challenges: Introduce time-based challenges or events that reward top participants with bonuses or unique badges.

Mechanics to earn the currency

The mechanics of earning currency in a game-based economy are integral to fostering active user engagement and driving desired behaviors. These systems can encompass a variety of methods, such as completing tasks or challenges, participating in activities that align with platform goals, or achieving specific milestones. For instance, users might earn points by contributing valuable content, answering questions, or consistently engaging with the community. Additionally, rewarding collaborative efforts, like team-based projects or peer mentoring, can further encourage interaction and a sense of community. However, it’s crucial that the earning mechanisms remain closely tied to meaningful actions that support the platform’s overarching mission. This alignment ensures that users are motivated not only to collect currency but to contribute positively to the overall ecosystem.

Here are some examples of mechanicts in games:

1. Quests and Missions:

• Daily/Weekly Quests: Provide short-term objectives to guide user activity, such as answering a set number of questions in a day or participating in moderation activities.
• Long-Term Missions: Develop broader goals that involve sustained interaction over time, rewarding users upon completion with significant rewards.

2. Community Events:

• Hackathons or Competitions: Organize events where users collaborate or compete on solving problems or building projects, with points and prizes as rewards.
• Themed Weekends: Host special events related to current events in tech, encouraging discussions or creative content related to recent innovations.

Spending & Using the currency

Spending and using currency in a game-based system is where user engagement transforms into tangible benefits, often serving as a powerful motivator for continued participation. By accumulating currency, users can unlock a variety of rewards and features, such as exclusive content, advanced tools, or customization options that enhance their personal experience. Additionally, currency can be used to amplify a user’s influence and visibility, allowing them to promote their contributions or elevate their status within the community. This exchange not only provides immediate gratification but also fosters a deeper connection to the platform’s ecosystem, as users invest earned currency back into the community. By offering meaningful opportunities for spending currency, platforms can maintain engagement levels and ensure that users continually feel invested in their growth and the community’s success.

1. Transactional Use:

• Purchasing: Users can exchange currency for goods or services within the platform, such as merchandise, access to premium content, or digital products.
• Trading or Bartering: Some platforms allow users to trade or sell items/services using currency, promoting user interaction. Or simply trade the currency, give gifts, etc.

2. Access and Privileges:

• Unlocking Features: Points may be used to unlock site functionalities such as advanced search, insights tools, or content creation features.
• Gaining Privileges: Users can “purchase” roles or access to areas (like private forums or beta features) that enhance their community standing or user experience.

3. Customization and Personalization:

• Avatar and Profile Enhancements: Currency can be used for cosmetic upgrades such as custom avatars, badges, themes, or profile enhancements.
• Personal Space Customization: Some platforms allow users to customize personal spaces or dashboards for a unique user experience.

4. Influence and Visibility:

• Content Promotion: Users might spend points to promote their questions, answers, or posts, increasing visibility.
• Voting Power: Enhance the weight of a user’s vote, allowing them to have more influence in polls or decision-making processes.

5. Community Engagement and Rewards:

• Gifting: Users can gift points or items to others as a form of recognition or reward for contributions.
• Event Participation: Use points for entry into special events, contests, or exclusive experiences.

6. Investment and Growth:

• Project Investment: Users could invest points in community projects or ideas, potentially sharing in the success if the project does well.
• Skill or Knowledge Purchases: Some systems allow investment in learning resources or mentorship opportunities to aid skill development.

7. Conversion and Real-world Applications:

• Converting to Real-world Benefits: Allow users to convert in-game currency into real-world benefits, like gift cards or charitable donations.
• Marketplace Use: Enable purchases in a marketplace, where points could potentially be used for goods or services provided by partner organizations.

8. Savings and Interest:

• Staking or Saving: Encourage users to save points, possibly earning interest or rewards over time for not spending immediately.

Conclusion

So here we are, standing at the threshold of transforming user engagement into a thriving, dynamic community. The journey ahead promises not only to reshape how interactions occur but also to redefine success on your platform. Game-based economies offer a blend of challenge and innovation, requiring thoughtful integration and a clear vision. The upcoming series will dive deeper into the specific elements—like points, badges, and virtual currencies—that form the backbone of these systems, showing how each component can be meticulously crafted to support individual project goals. As you embark on this adventure of implementation, remember that while the mechanics may be intricate, the reward is a vibrant ecosystem teeming with motivated and active participants. So gear up for the journey—a game-based economy may just be the catalyst that creates the next great learning platform.

The post Game Based Economies appeared first on Mike Lynch.

Introduction

Every time I get a new Mac, I update my process for setting up a new mac, and then I let it languish as time passes, until, I get a new computer. My previous post was kept up to date-ish as time went on, but this post is a revision to that one, where instead of focusing on individual commands that I have to remember, focusing on setting up a script that will just set everything up, and then go away.

This was started with my dotfiles updates. As I have multiple computers, my goal was to have all of them have a terminal that was similar enough, that it would not be difficult to move between them. However, I realize that it’s not just shell aliases and shell prompts that need to be kept aligned for this to keep working.

For one thing, I move between Windows, MacOS X, and Ubuntu (Linux) often. On windows, I use WSL, so I use mostly Ubuntu, and then I have several computers that run linux at home, that also use Ubuntu. So between the multiple OSes and the various different purposes, I found that I don’t have a one size fits all script that handles them, until now!

(I’m kidding, if you were hoping that I had a one size fits all script that set up Windows/Ubuntu/OSX for multiple different purposes, I think that would be amazing, but unlikely something I would put much effort into building, as the other issue with the dotfiles and the setups for development is; it’s always changing.

I used to use bash, now I use zsh, at one point I had a lot of python setup scripts, and now I use uv. There are always changes and updates. However I have not given up entirely on this goal. I’m still maintaining dotFiles. I still plan to upate them once every 2-3 years

Here is the original post.

Setting Up a New Mac for Development

In gitHub I have a repo called, appropriately, “dotFiles”. This is a great place to start if you are also trying to set up a mac for development, just search gitHub for dotFiles, and you will find many, many people who have already tried to help you set up your Mac, just like I’m doing now. There are many flavors of dotFiles, some that are just the shell configurations, and some that attempt to add software and are os specific. Mine are a combination of both, the configuration files are good for multiple zsh shells.

Step 1: Pulling the Repo

The first thing is to pull the dotFiles repository from git. It’s important to decide where to do that from. Some dotFiles (as mine) are designed to be pulled into your home directory. That is not a great place to have a git repository in general, one reason for this is that you will have ~/Documents, ~/Downloads, and other various folders hanging off of that home folder, so it’s not ideal to have that be a gitHub repository. I have experimented with two approaches:

• SymLink: The first is to pull the repository to another folder (say ~/dev/dotFiles), and then symlink the folders to your home directory. This approach benifits from being able to keep the dotFiles in sync with your repository, so changes can continue to be made, and pushed back to the repo, or pulled from another machine. The con of this system is symLinks mean you can’t make a change for any one computer, as it’s in the repo (of course you can create a branch, and manage it that way.)
• Shallow Pull: The second way was to do a shallow pull. In this way you can actually pull it right into your home directory, and then break the connection to your repo. The good is that it’s independent from the repo, so changes can be made, the bad is that you can’t make changes and push it up.

So those are the options I’ve tried, there may be others.

In the end, I ended up going with the Shallow Pull Option, but I do still think the symlink might be the way to go.

 cd ~
 git clone --depth=1 git@github.com:nycynik/dotFiles.git .dotfiles
 rm -rf ./.dotfiles/.git

After pulling the dotfiles, you then remove the .git directory, severing the link to the original repository, and since you have only pulled the most recent files (no history) that is all you need to complete the shallow copy.

As you can see this is being run from the home directory, again, if you opt for the symlink version, you would place it elsewhere, and then symlink the .dotfiles folder to your home.

cd <somewhere dev files are saved>
git clone git@github.com:nycynik/dotFiles.git 
ln -s dotFiles/.dotfiles ~/.dotFiles

Step 2: Run the installation script

As I said, this dotfiles is not just a configuration, but also a setup script. so the next step is to run the script and have it work the magic setup. Here we go!

cd ~
source .dotfiles/setup.sh

The script will then as you a few questions, and begin installing all the things.

The script first detects the OS, it can be wrong, so you also can choose which OS you are running. Next it collects some basic information it uses during the configuration. I would love to expand that at some point to include which development tools you wanted to use.

Finally, the script runs and sets up the environment. It still has some bash configuration in it, but it’s mostly focused on zsh configuration.

It may still be interactive, as some of the setup steps require authentication, but mostly it should run smoothly, and when finished you will see a set of ToDos that you may want to do.

There is also a brew log that should be reviewed as it’s often the case that brew has some nifty suggestions of it’s own. The log is at ${HOME}/.dotfiles/brew_log.log, this is often the same as ~/.dotfiles/brew_log.log.

Conclusion

So, in the end this script worked on all three of my setups, WSL, Linux, and OSX. I don’t have much of a setup for actual Windows. There would be a lot of additional work to get that to work. I think the main thing it would have to do is setup WSL

This script and the combined configuration files are all available in the same git repo.

The post DotFiles: New Computer Setup Automation appeared first on Mike Lynch.

When you’ve spent years immersed in building sleek and responsive apps on iOS using Swift and Objective-C, the opportunity to delve into new territories like Dart and Flutter presents itself as an exciting adventure. I recently embarked on a journey to learn to build apps with Flutter, and this is my initial experience. I will say, that I’m primarily still focused on iOS app development, but I am always interested in being able to offer Android Apps in addition to the iOS apps. And that is typically difficult to do, having to manage two individual apps can be quite time-consuming. Every update in one requires an update in the other, and you also have to keep on top of both OS revisions, tool revisions, etc. It’s quite a lot to expect a single engineer to manage Android and iOS development well. So the idea of using a cross-platform tool is very exciting.

The Entryway: Dart and Flutter

The Dart language reminded me of Kotlin, or Java. Dart’s syntax is clear and concise, and though it deviates from Swift, I found it readable and pleasant. Dart can be executed using a Dart virutal machine and Just-In-Time compilation and/or it can be compiled to native code. Offering both makes development easier, and production build run fast. I really enjoyed Dart.

Flutter is like a robust, externally sourced framework that transforms UI building. It reminds me a bit of Apache Flask. Here is a random example of flask and flutter for a login screen, just to show how they are similar. I suppose all UI frameworks are similar, and I also saw similarities with UI building in iOS (but lacking the awesome tooling of XCode)

<?xml version="1.0" encoding="utf-8"?>
<s:Application xmlns:fx="http://ns.adobe.com/mxml/2009" 
               xmlns:s="library://ns.adobe.com/flex/spark" 
               xmlns:mx="library://ns.adobe.com/flex/mx" 
               minWidth="955" minHeight="600">
    
    <s:VGroup horizontalAlign="center" verticalAlign="middle" width="100%" height="100%">
        <s:Label text="Login" fontSize="24" marginBottom="20"/>
        <s:Form width="300">
            <s:FormItem label="Username:">
                <s:TextInput id="usernameInput"/>
            </s:FormItem>
            <s:FormItem label="Password:">
                <s:TextInput id="passwordInput" displayAsPassword="true"/>
            </s:FormItem>
            <s:Button label="Login" click="login()"/>
        </s:Form>
    </s:VGroup>
    
    <fx:Script>
        <![CDATA[
            private function login():void {
                // Handle login logic here
                var username:String = usernameInput.text;
                var password:String = passwordInput.text;
                trace("Username: " + username + ", Password: " + password);
            }
        ]]>
    </fx:Script>

</s:Application>

import 'package:flutter/material.dart';

void main() {
  runApp(MyApp());
}

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Flutter Login',
      theme: ThemeData(
        primarySwatch: Colors.blue,
      ),
      home: LoginScreen(),
    );
  }
}

class LoginScreen extends StatelessWidget {
  final TextEditingController _usernameController = TextEditingController();
  final TextEditingController _passwordController = TextEditingController();

  void _login(BuildContext context) {
    final username = _usernameController.text;
    final password = _passwordController.text;
    print('Username: $username, Password: $password');
    // Handle login logic here
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: Text('Login'),
      ),
      body: Padding(
        padding: const EdgeInsets.all(16.0),
        child: Column(
          mainAxisAlignment: MainAxisAlignment.center,
          children: <Widget>[
            TextField(
              controller: _usernameController,
              decoration: InputDecoration(labelText: 'Username'),
            ),
            TextField(
              controller: _passwordController,
              decoration: InputDecoration(labelText: 'Password'),
              obscureText: true,
            ),
            SizedBox(height: 20),
            ElevatedButton(
              onPressed: () => _login(context),
              child: Text('Login'),
            ),
          ],
        ),
      ),
    );
  }
}

Widgets: Flutter’s Building Blocks

In Flutter, everything is a widget—a bit like UIView, but with greater range and composability. Stateless and Stateful widgets are Flutter’s equivalents to plain old structuring and dynamic, event-driven view controllers. Understanding widget trees becomes pivotal, much like mastering UIView hierarchies in iOS.

The example above shows quite a few widgets. But it really gets interesting when you are building an app, and deciding which widgets you want to use for what. There are many choices and best practices to learn as you go.

Cocoapods? Meet Pubspec.yaml

One impending question was, where’s my Podfile? In Flutter, pubspec.yaml steps in. This Flutter file manages your project’s packages—akin but not quite a direct replacement to CocoaPods in the iOS ecosystem. After adding dependencies here, running ‘flutter pub get’ will fetch the necessary packages. Here is an excerpt of the pubspec from the app. As you can see it has dependencies, but also defines the app, including assets and fonts.

name: fc_mobile
description: "Client  Mobile app mostly focused on reading content."
# The following line prevents the package from being accidentally published to
# pub.dev using `flutter pub publish`. This is preferred for private packages.
publish_to: 'none' # Remove this line if you wish to publish to pub.dev

# The following defines the version and build number for your application.
# A version number is three numbers separated by dots, like 1.2.43
# followed by an optional build number separated by a +.
# Both the version and the builder number may be overridden in flutter
# build by specifying --build-name and --build-number, respectively.
# In Android, build-name is used as versionName while build-number used as versionCode.
# Read more about Android versioning at https://developer.android.com/studio/publish/versioning
# In iOS, build-name is used as CFBundleShortVersionString while build-number is used as CFBundleVersion.
# Read more about iOS versioning at
# https://developer.apple.com/library/archive/documentation/General/Reference/InfoPlistKeyReference/Articles/CoreFoundationKeys.html
# In Windows, build-name is used as the major, minor, and patch parts
# of the product and file versions while build-number is used as the build suffix.
version: 1.0.0+1

environment:
  sdk: ^3.5.3

# Dependencies specify other packages that your package needs in order to work.
# To automatically upgrade your package dependencies to the latest versions
# consider running `flutter pub upgrade --major-versions`. Alternatively,
# dependencies can be manually updated by changing the version numbers below to
# the latest version available on pub.dev. To see which dependencies have newer
# versions available, run `flutter pub outdated`.
dependencies:
  flutter:
    sdk: flutter

  # The following adds the Cupertino Icons font to your application.
  # Use with the CupertinoIcons class for iOS style icons.
  cupertino_icons: ^1.0.8

  # adding Firebase libs
  firebase_core: ^3.4.0
  firebase_auth: ^5.2.0
  # cloud_functions: ^4.1.0
  cloud_firestore: ^5.4.0
  firebase_storage: ^12.2.0
  firebase_ui_auth: ^1.16.0
  google_fonts: ^6.2.1

  # intl
  flutter_localizations:
    sdk: flutter
  easy_localization: ^3.0.0
  
  # cached images
  cached_network_image: ^3.3.0

Making the UI iOS-Like

Creating an iOS-like UI in Flutter is undoubtedly possible. Flutter’s Cupertino library translates familiar native iOS aesthetics, from navigation bars to icons, into the widget ecosystem. However, it’s not plug-and-play. Attention to design patters and some fine-tuning, like adjusting fonts and icons, goes a long way in capturing that sleek iOS feel.

Building for iOS

When it’s time to build for iOS, Flutter’s integration with Xcode simplifies the process. Running ‘flutter run’ felt parallel to the smooth process within Xcode—after getting provisioning profiles and certificates in order, of course. The Flutter DevTools also provide a user-friendly route for debugging, offering instruments that are intuitive even for seasoned iOS developers.

The Ecosystem and Community

Whenever I hit roadblocks, the Flutter and Dart community emerged as an invaluable resource. Thanks to detailed documentation and a large community, finding solutions and exploring examples felt very collaborative. Platforms like GitHub are teeming with open-source plugins to augment your apps. For instance, StackOverflow has quite a few answers at the ready.

Wrapping Up

My Flutter project was both an enlightening and challenging experience. It’s a powerful toolkit that offers cross-platform capabilities—isolating from platform constraints. The transition wasn’t without hitches, but Flutter’s structured support system smooths the learning curve significantly.

For any iOS dev contemplating venturing into the cross-platform world, Flutter seems like a dream come true. Not without issues of it’s own, and of course game development is it’s own mixture of tradeoffs, but for many business like applications, Flutter seems fantastic.

The post Moving Swiftly, to Dart appeared first on Mike Lynch.

Recently I was building a project on a windows machine that required Cypress e2e testing. I use Windows Subsystem for Linux (WSL2) for most of my development work. I needed to be able to run X11 so that linux could run the browser on Windows OS. To accomplish this, I set up XLaunch, however there is a gotcha. The easist way to get that to work is to skip Authentication. This is never a great idea, even if this computer was not a laptop and never left the building. Thanks to sfmontyo, I was able to get the setup working with authentication.

Install XLaunch

Step one is installing Xming, this is a set of tools that allow you to have a X Windows Server running in Windows. Hop over to their official site and begin by downloading the installer. Once you download the installer, simply run it and follow the wizard. Once installed you are ready for the next step.

Configure X Authentication

Assuming that your WSL2 operating system is Ubuntu, the following steps will work for you, you may need to adapt them if you have another OS installed.

sudo apt install -y xauth coreutils gawk gnome-terminal 
xauth list # this should be an empty list
magiccookie=$(echo '{some-pass-phrase}'|tr -d '\n\r'|md5sum|gawk '{print $1}')
xauth add host.docker.internal:0 . $magiccookie
cp ~/.Xauthority /mnt/c/Users/{WindowsUserName}

Be sure to replace your username in the last line, and you should also change the some-pass-phrase. Considering the level of security intended here, you really only need to recall this password for the moment of this installation. After you are done here, you won’t need it again, and if you find the password some how changes, or does not work, you can follow the same steps to recreate the authentication. With that in mind, I recommend some long random string.

With that done, you have now set up authentication, and are ready to set up the terminal.

Setup X11 for your shell

you need to export the shell, the best option for hostname is to use docker, as show here:

export DISPLAY=host.docker.internal:0

DISPLAY is what X11 uses as the place to send content. Since WSL runs under docker, that hostname is the same as the local Windows OS, and so this should work regardless of your IP changes and networking setup. To make this persistent, you will need to add this to your shell of choice. If using bash, you can add it to your `~/.bash.rc`, if you are using a different shell, add it as is normal for that shell.

Setup XLaunch

The last step is to run XLaunch on windows startup, using the authentication that was copied over in step 1. To being, open your startup folder. To do this, you can click windows, and then type run. The run dialog will show, and you can type shell:startup to open the folder in the explorer.

This window will open, where you need to create an alias to your VcXsv with Xauthority. You can drag and drop XLaunch from the applications folder into the window that is now open, and if you do so while holding the right click, you can have it create a shortcut.

Edit the Target, and add the command line arguments that you need to use X Authority, here is the single line that you need:

“C:\Program Files\VcXsrv\vcxsrv.exe” -multiwindow -clipboard -wgl -auth “C:\users\{youruser}\.Xauthority”

Try it out

Next you will need to run an X application on the host, and you should see it running in windows. Some of the XApplications that are often installed are xclock and xeyes, these were widget type applications that have stood the test of time.

Assuming that is working for you, Congratulations! You have x11 set up with Authentication! Go you!

References:

• https://support.microsoft.com/en-us/windows/configure-startup-applications-in-windows-115a420a-0bff-4a6f-90e0-1934c844e473
• https://stackoverflow.com/questions/66768148/how-to-setup-vcxsrv-for-use-with-wsl2

The post Using X11 with WSL2 appeared first on Mike Lynch.

If you’re a mobile app developer, you’ve likely heard of Jenkins—a powerful automation tool that helps streamline your build process. It’s widely used for continuous integration (CI) and continuous delivery (CD) in all sorts of development environments. But if you’re building iOS apps, Jenkins alone won’t be enough. Since Apple requires macOS to compile iOS apps, you need a Mac in the equation.

In this post, I’ll guide you through setting up Jenkins to use a macOS machine as an agent for building iPhone apps. This post assumes you already have Jenkins running on your local network, and you can build your app on the Mac you’ll be using. We’ll skip SSH setup and focus on using Jenkins’ inbound agent instead. Let’s dive in!

How to Set Up Jenkins Agent on macOS

Step 1: Create the Jenkins User on Your Mac

The first thing we need is a dedicated user account for Jenkins on your Mac. This keeps things organized and avoids permission issues down the road. Here’s how to create the user:

1. Open the terminal on your Mac.
2. Run the following command to create a user named jenkins:

sudo sysadminctl -addUser jenkins -fullName "Jenkins User" -password <a password for jenkins>
sudo dscl . -change /Users/<username> NFSHomeDirectory <old-path> <new-path>
sudo su jenkins
# set your shell
chsh -s /usr/bin/zsh
# setup keychain
mkdir -p /Users/jenkins/Library/Keychains
security create-keychain -p <password> /Users/jenkins/Library/Keychains/Login.keychain.db
security set-keychain-settings -t 3600 -l ${HOME}/Library/Keychains/login.keychain

3. Give the new user permission to use all the tools required to build your app. Add the necessary setup to this user’s .zshrc file ~/.zshrc. There is a whole lot of configuration for the tools you might need for development. (You might check out my other post on setting up a mac for development, much of this file is from that.

export LANG=en_US.UTF-8
export LC_ALL=en_US.UTF-8

# if not already set up on your machine, add basic paths.
# export PATH="/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:$PATH"

# brew
export PATH=/opt/homebrew/bin:/opt/homebrew/sbin:$PATH

# nvm
export NVM_DIR="$HOME/.nvm"
[ -s "/opt/homebrew/opt/nvm/nvm.sh" ] && \. "/opt/homebrew/opt/nvm/nvm.sh"  # This loads nvm
[ -s "/opt/homebrew/opt/nvm/etc/bash_completion.d/nvm" ] && \. "/opt/homebrew/opt/nvm/etc/bash_completion.d/nvm"  # This
 loads nvm bash_completion

# Pyenv
export PYENV_ROOT="$HOME/.pyenv"
export PATH="$PYENV_ROOT/bin:$PATH"
if command -v pyenv 1>/dev/null 2>&1; then
   eval "$(pyenv init -)"
fi

# python virtualenv
if which pyenv-virtualenv-init > /dev/null; then
  eval "$(pyenv virtualenv-init -)";

4. Don’t forget to set up the login keychain for Jenkins to access code-signing certificates. To do that, log in as the Jenkins user and open Keychain Access. Make sure it can unlock the login keychain automatically, or If you prefer to not check that box, you can log in each time you connect to the job by adding this to your build process:

security -v unlock-keychain -p "$KEYCHAIN_PASSWORD" 

Step 2: Download the Jenkins Agent Jarfile

Now that we have our user, we’ll configure the Jenkins agent on this Mac. We do that by downloading a small .jar file that connects the Mac to the Jenkins server.

1. Go to your Jenkins web interface and navigate to Manage Jenkins > Manage Nodes and Clouds.
2. Create a new node, name it something like Mac-Agent, and assign it the mac-dev label.
3. Once the node is created, you’ll be given a command to run on the Mac, including a URL to the agent .jar file.
4. Download the jarfile to your Mac, ideally in a folder like /Users/jenkins/agent/. Run:

   mkdir -p /Users/jenkins/agent
   cd /Users/jenkins/agent
   wget http://<jenkins-server>:8080/jnlpJars/agent.jar

Step 2b: Have the agent run all the time as a service.

To have this run all the time, you can create a launchd plist and set the service to run always.

1. Create a plist file to configure the agent as a service:

sudo nano /Library/LaunchDaemons/org.jenkins.agent.plist

Add the following content to the plist file:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
    <key>Label</key>
    <string>org.jenkins.agent</string>
    <key>ProgramArguments</key>
    <array>
        <string>/usr/bin/java</string>
        <string>-jar</string>
        <string>/Users/jenkins/agent/agent.jar</string>
        <string>-jnlpUrl</string>
        <string>http://your-jenkins-server/computer/MacAgent/slave-agent.jnlp</string>
        <string>-secret</string>
        <string>@${secret key file}</string>
        <string>-workDir</string>
        <string>/Users/jenkins/agent</string>
    </array>
    <key>RunAtLoad</key>
    <true/>
    <key>KeepAlive</key>
    <true/>
</dict>
</plist>

Adjust the paths to match your setup and fill in the jnlpUrl and secret values. Save the file and you can have the mac run it when it starts.

sudo launchctl load /Library/LaunchDaemons/org.jenkins.agent.plist

Step 3: Configure the Agent to Run as a macOS Node

You’ve got the agent file in place, so now we’ll register the Mac as a Jenkins node.

1. Head back to your Jenkins server, and under the Nodes configuration for Mac-Agent, you’ll see a unique secret for that node. You’ll need this secret to run the agent.
2. Start the agent on your Mac with the following command:

 java -jar /Users/jenkins/agent/agent.jar -jnlpUrl http://<jenkins-server>:8080/computer/Mac-Agent/slave-agent.jnlp -secret <secret> -workDir "/Users/jenkins/agent"

3. You should now see the Mac connected as an agent in the Jenkins UI. Congratulations, you now have a mac agent that can build your mobile apps!

Step 4: Set the Node Label for macOS Builds

To ensure your builds run on this macOS agent, we need to assign it a label. I suggest using something like mac-dev to easily identify this agent for macOS development.

1. In Jenkins, go to Manage Jenkins > Manage Nodes and Clouds.
2. Edit the Mac-Agent node and assign it the label mac-dev.

Building a Test Project

Let’s verify everything is working by creating a test project that runs a simple macOS command on our Jenkins agent.

1. Create a new job in Jenkins by navigating to New Item.
2. Name the project something like Mac Test Project and set it to be a Freestyle project.
3. Under Restrict where this project can be run, add the label mac-dev to ensure it runs on the Mac agent.
4. In the Build section, add an Execute Shell step with a basic macOS command like:

security unlock-keychain -p PASSWORD ${HOME}/Library/Keychains/login.keychain

echo "Hello from macOS"

5. Save the project and run the build.

If everything is set up correctly, you’ll see the output from the Mac in your Jenkins console log, proving the agent is connected and working properly.

Final Thoughts

While you can easily build iOS apps in the cloud for a fee, there’s something satisfying about running your builds on your own hardware, especially if you’re building your own apps like I do. With this Jenkins setup, you have full control over the build environment, which is invaluable for mobile development. As you maintain your own build toolchain as you build the app, it also maintains your build env. Wonderful!

If you’re just getting started, don’t be discouraged by the complexity of CI systems like Jenkins. Once it’s set up, it’ll save you time and effort in the long run, giving you more freedom to focus on what matters—building your game or app!

Happy coding!

References

• https://stackoverflow.com/questions/42627269/jenkins-using-git-askpass-to-set-credentials
• https://stackoverflow.com/users/882754/tanguy-g : https://stackoverflow.com/questions/41680511/jenkins-where-is-the-login-keychain-file-in-users-name-library-keychains-fol

The post Building Mobile Apps with Jenkins and macOS appeared first on Mike Lynch.

Overview

In the world of modern software development, microservices architecture has become increasingly popular for its scalability and maintainability. As developers, we often need to run and test these microservices locally before deploying them to a cloud-based Kubernetes cluster. Let’s get started setting up a local Kubernetes environment using MicroK8s, a lightweight, single-package Kubernetes distribution, perfect for local development. We’ll also cover a basic setup with Terraform to help you seamlessly transition to cloud deployment.

Why MicroK8s?

MicroK8s is an easy-to-install, low-ops Kubernetes distribution that runs on your local machine. It provides a great way to develop and test microservices locally before pushing them to a production environment. Some benefits of using MicroK8s include:

• Simplicity: Installation is straightforward, and you can have a fully functional Kubernetes cluster running in minutes.
• Lightweight: It consumes fewer resources than full-blown Kubernetes setups, making it ideal for local development.
• Modular: You can enable and disable Kubernetes features like DNS, storage, and more with simple commands.
• Consistency: The setup mimics a cloud-based Kubernetes environment, ensuring that your local testing closely resembles the production environment.

Step 1: Installing MicroK8s

To get started, you’ll need to install MicroK8s on your development machine. Follow these steps:

1. Install MicroK8s:
   MicroK8s can be installed using a snap package, which is supported on most Linux distributions.

   sudo snap install microk8s --classic

This command will install MicroK8s with all necessary dependencies. If you’re not developing on a Linux machine, you can find instructions for the installation in on the official site.

2. Add Your User to the MicroK8s Group:
   To avoid needing sudo for every command, add your user to the microk8s group.

   sudo usermod -aG microk8s $USER
   sudo chown -f -R $USER ~/.kube

Log out and log back in to apply the changes.

3. Enable Essential Add-ons:
   MicroK8s comes with several add-ons that are disabled by default. Enable the ones you need with the following commands:

   microk8s enable dns dashboard storage

• dns: Provides DNS resolution within your cluster.
• dashboard: A web-based UI for Kubernetes.
• storage: A local storage solution for persistent volumes.

1. Verify Your Installation:
   Check the status of your MicroK8s installation to ensure everything is running smoothly.

   microk8s status --wait-ready

You should see that the Kubernetes services are active and ready.

Step 2: Configuring kubectl for MicroK8s

To interact with your Kubernetes cluster, you’ll use kubectl. MicroK8s comes with its own version of kubectl, but you can alias it to avoid conflicts with other Kubernetes installations.

alias kubectl='microk8s kubectl'

This alias ensures that all kubectl commands target your MicroK8s cluster.

Step 3: Setting Up Terraform for Local Deployment

Terraform is a powerful tool for provisioning infrastructure as code. We can use it to deploy resources to your local MicroK8s cluster and later transition to a cloud provider like AWS, GCP, or Azure.

1. Install Terraform:
   If you haven’t already, download and install Terraform from the official website.
2. Create a Terraform Configuration:
   Start by defining a basic Terraform configuration that will create Kubernetes resources locally. Here’s an example main.tf:

   provider "kubernetes" {
     config_path = "~/.kube/config"
   }

   resource "kubernetes_namespace" "example" {
     metadata {
       name = "example-namespace"
     }
   }

   resource "kubernetes_deployment" "nginx" {
     metadata {
       name      = "nginx-deployment"
       namespace = kubernetes_namespace.example.metadata[0].name
     }

     spec {
       replicas = 2

       selector {
         match_labels = {
           app = "nginx"
         }
       }

       template {
         metadata {
           labels = {
             app = "nginx"
           }
         }

         spec {
           container {
             image = "nginx:latest"
             name  = "nginx"
           }
         }
       }
     }
   }

This configuration defines a Kubernetes namespace and a simple Nginx deployment within that namespace.

3. Initialize and Apply Terraform:
   Initialize Terraform to download the necessary providers and then apply the configuration.

   terraform init
   terraform apply

Terraform will deploy the resources to your local MicroK8s cluster.

Step 4: Transitioning to Cloud Deployment

Once you’ve developed and tested your microservices locally, you can easily transition to deploying them on a cloud-based Kubernetes cluster. The main changes involve updating your Terraform provider configuration to point to your cloud provider’s Kubernetes service and ensuring your cloud infrastructure is set up accordingly.

For example, if you were to deploy to Google Kubernetes Engine (GKE), you would modify the provider block in your Terraform configuration:

provider "kubernetes" {
  host                   = "<GKE API Server Endpoint>"
  token                  = "<Your GCP Access Token>"
  cluster_ca_certificate = file("<Path to CA Certificate>")
}

This allows you to use the same Terraform scripts to manage both your local and cloud deployments, providing a smooth and consistent development workflow.

Happy Coding

Running Kubernetes locally with MicroK8s is a great way to develop and test your microservices before deploying them to a production environment. By combining MicroK8s with Terraform, you can maintain a consistent infrastructure-as-code approach across both local and cloud environments, ensuring a seamless transition from development to production.

Just one more note, this type of architecture is not for everyone. If you are creating a single service, or starting a new project, I highly recommend you begin with something simple to deploy such as Google Firebase.

The post Getting Started with Local Kubernetes: Developing Microservices with MicroK8s appeared first on Mike Lynch.

Ollama is an open-source AI model that provides a sophisticated AI chatbot. Running it locally means you don’t need to pay any additional API fees and it’s great if you want to do local development. Following these simple instructions enables you to set it up a local free-to-use AI to chat with. This is based on the instructions found on the Open WebUI GitHub Page.

Installing Software

Docker

If you are not an engineer, you may not have Docker installed. Docker is not the only Virtual Container software you can run, but it is the most popular currently and it’s free for individual use. Head over to their site to download and install docker, it’s quite simple. The tool we are using is ‘Docker-Desktop’ and if you are using Windows or Mac the installation is currently very similar. After you download the appropriate installer, you just run it and follow along with the wizard.

Now that you have docker installed, you will really not need to interact much more with it for the rest of this installation, just having it there and running is all you need. Depending on your setup, you might need to restart your machine.

To verify that it is working as expected, you need to open a terminal window. Once open to verify docker is installed, you may type docker --version (results are shown in the image below.

Ollama

As I mentioned this is a very short tutorial! The next step after installing docker is to run Ollama and WebUI.

docker run -d -p 3000:8080 --gpus=all -v ollama:/root/.ollama -v open-webui:/app/backend/data --name open-webui --restart always ghcr.io/open-webui/open-webui:ollama

After running the command above for the first time, docker will download and install all the required software and run a local container hosting the WebUI application that will allow you to access your local version of Ollama. You can verify that it is working, by looking at the ‘Containers’ tab in the Docker UI, shown in the image below.

Chatting With AI Locally

Once the previous command completes your local Chat AI is ready to talk to you! To begin, open the Web UI by clicking this link.

NOTE: If you restart your computer, you will need to run that command again to restart the WebUI.

http://localhost:3000

The first time you open this site, it will ask you to log in. Create and account and login. Then you will be able to chat.

More Models

If you are interested, there are more models that you can install through the WebUI interface. If you code for example, you may want to install an AI that is trained specifically for coding, such as codellama. Installing new models is quite easy, visit the link below.

http://localhost:3000/workspace/models

Happy Chatting!

Getting started with AI has never been easier, I hope you enjoy your new AI friend.

If you get stuck, or just want to copy/paste easier, here is a GitHub Repository with the example above.

The post Local Chatting with Ollama appeared first on Mike Lynch.

When developing games, you often need to create tools that go with the games to speed development. This can be complicated tools such as level editors or simple tools such as image generation scripts. I was recently working on a project where I needed many game tiles for each letter of the alphabet, and although this is pretty simple to do using a professional tool such as PhotoShop, I decided to write a script to do it.

Python Script

The script is written in Python and can be found in GitHub, here.

This is a simple tool that opens a base image and then using the script writes a single letter centered on the image. This was quick to build and can be modified if the project calls for it. For example, maybe the font needed to change, or we needed new colors or new tiles. Any of these options could be done and regenerated in seconds.

The script uses the Pillow Library, a very powerful image manipulation library that can do all sorts of interesting things with images. In this case it’s simply being used to draw the text on the images.

def draw_text_on_image(image, text, output): 
    draw = ImageDraw.Draw(image)

    font = ImageFont.truetype("font/AlumniSansCollegiateOne-Regular.ttf", 225)
    text_color = (200, 128, 128) 
    text_color_back = (40, 10, 10) 
    width, height = image.size

    box = draw.textbbox((1,1), text=text, stroke_width=1, font=font)

    text_width = box[2] - box[0]
    text_height = box[3] - box[1]

    # text_width, text_height = draw.textsize(text, font)
    x = (width - text_width) / 2
    y = (height - text_height) / 2

    draw.text((x+5, y), text, stroke_width=1, fill=text_color_back, font=font)
    draw.text((x-5, y-10), text, stroke_width=0, fill=text_color, font=font)

    image.save(output)   

The script first sets the settings for the text that will be written, this is the font, and the text color, and then sets the second text color to black (in this case we are doing the letter with an offset backing letter to make the letter stand out a bit more.

Then we calculate the center of the image and move it back half of the height and width so that the text will be centered on the image.

We then drew the letter twice, once in black, and once in the chosen color. As you can see it’s a simple 10-pixel offset, but to keep it centered, we move the top text left, and the back text right.

Final Image output:

The post Simple Image Generation Script appeared first on Mike Lynch.

This is a proposal for a classification of AIs that would apply well to any AI application or device designed to offer a service to users. There are several examples after the proposed classification.

Classification

The Classification includes six levels:

1. Interface Control
2. Basic Data Interaction
3. Contextual Understanding
4. Autonomous Learning
5. Advanced Adaptation
6. Continuous Learning

Each classification Level is described below.

1. Level 1 Interface Control
   • Non-AI Interface At this level, the AI system primarily functions as a non-intelligent interface that requires explicit human input to control and perform specific tasks. It lacks the ability to learn or adapt independently.
2. Level 2 Basic Data Interaction
   • At this level, the AI system can interact with and analyze a limited set of data inputs. It can perform tasks or provide insights based on predefined rules or algorithms, but still depends on human input to guide its decision-making process.
3. Level 3 Contextual Understanding
   • At this level, the AI system can comprehend and interpret data in a more contextual manner by leveraging natural language processing or image recognition. It is capable of processing unstructured data and extracting relevant information, reducing the amount of human input required for understanding complex data.
4. Level 4 Autonomous Learning
   • At this level, the AI system possesses the ability to learn and improve its performance by using algorithms and techniques like machine learning. It can adapt its behavior based on previous interactions, reducing the need for constant human intervention and decision-making.
5. Level 5 Advanced Adaptation
   • At this level, the AI system can self-adapt and optimize its performance based on continuous interactions with users and additional data inputs. It utilizes advanced techniques like deep learning to improve its decision-making capabilities without relying heavily on human input.
6. Level 6 Continuous Learning and Adaptation
   • At this final level, the AI system becomes self-sufficient and capable of continuous learning and adaptation. It harnesses its ability to read and understand data, make predictions, and autonomously improve its performance over time. At this stage, the AI interface no longer requires human input but continues to read data from various sources to enhance its knowledge and decision-making abilities.

Examples

Doorbell

Let’s apply this to a doorbell.

1. Interface Control (Non-AI Interface): A traditional doorbell that requires the user to manually press a button to produce a sound. The doorbell has no AI capabilities and solely serves as an interface controlled by human input.
2. Basic Data Interaction: A doorbell equipped with a motion sensor that triggers the sound when it detects movement. The AI system can analyze basic data (motion) to produce a response but still relies on predefined rules and simple data inputs.
3. Contextual Understanding: A doorbell equipped with a camera and a facial recognition system. When a person approaches the door, the AI system uses the camera to recognize familiar faces and plays customized sounds or notifications based on the recognized individual.
4. Autonomous Learning: A doorbell AI system that utilizes data from the camera and audio inputs to learn the patterns and preferences of the residents. Over time, it adapts and learns to differentiate between familiar faces, delivery people, or potential threats, and adjusts its response accordingly.
5. Advanced Adaptation: A doorbell AI system that employs advanced machine learning algorithms and audio processing. It can recognize and differentiate between specific sounds, such as the sound of a delivery truck or a barking dog, and adjusts its notifications or responses based on these learned sound patterns.
6. Continuous Learning: A doorbell AI system that continuously analyzes data from the camera, audio inputs, and other sources. It can learn and adapt its behavior to various scenarios, such as predicting the likelihood of a visitor being a regular guest or a new acquaintance, without requiring explicit human input or customization.

Thermostat

A second example, considering a thermostat.

1. Interface Control (Non-AI Interface): A basic thermostat that requires users to manually adjust the temperature settings by pressing physical buttons or turning a dial.
2. Basic Data Interaction: A thermostat equipped with sensors that detect the current temperature and humidity levels in a room. The AI system can use this data to maintain the desired temperature as configured by the user but requires manual input to set the preferences.
3. Contextual Understanding: A thermostat that integrates with weather forecasts and considers factors like outdoor temperature and user occupancy patterns to adjust the temperature automatically. It can analyze contextual data to optimize the indoor environment, reducing the need for explicit human input.
4. Autonomous Learning: A thermostat AI system that learns from user preferences, adjusting the temperature based on patterns, time of day, and user behavior. Over time, it adapts and optimizes temperature settings to provide a comfortable environment without constant manual input.
5. Advanced Adaptation: A thermostat AI system that employs advanced machine learning algorithms to analyze historical data, user feedback, and energy usage patterns. It can predict and adapt temperature settings based on occupancy patterns, weather changes, and personal preferences, optimizing energy efficiency and comfort.
6. Continuous Learning: A thermostat AI system that constantly learns from user interactions, external factors like weather patterns, and energy usage. It can autonomously adjust temperature settings, anticipate user needs, and adapt based on various inputs without requiring regular input from the user.

Conclusion

I believe that this classification could help guide people who are trying to understand the capabilities of a ‘smart’ device or of an AI system. Having the classification would help speed up our understanding of what the systems are designed to be capable of.

The post An AI Classification Proposal appeared first on Mike Lynch.