by Joche Ojeda | May 22, 2024 | A.I
A New Era of Computing: AI-Powered Devices Over Form Factor Innovations
In a recent Microsoft event, the spotlight was on a transformative innovation that highlights the power of AI over the constant pursuit of new device form factors. The unveiling of the new Surface computer, equipped with a Neural Processing Unit (NPU), demonstrates that enhancing existing devices with AI capabilities is more impactful than creating entirely new device types.
The Microsoft Event: Revolutionizing with AI
Microsoft showcased the new Surface computer, integrating an NPU that enhances performance by enabling real-time processing of AI algorithms on the device. This approach allows for advanced capabilities like enhanced voice recognition, real-time language translation, and sophisticated image processing, without relying on cloud services.
Why AI Integration Trumps New Form Factors
For years, the tech industry has focused on new device types, from tablets to foldable screens, often addressing problems that didn’t exist. However, the true advancement lies in making existing devices smarter. AI integration offers:
- Enhanced Productivity: Automating repetitive tasks and providing intelligent suggestions, allowing users to focus on more complex and creative work.
- Personalized Experience: Devices learn and adapt to user preferences, offering a highly customized experience.
- Advanced Capabilities: NPUs enable local processing of complex AI models, reducing latency and dependency on the cloud.
- Seamless Integration: AI creates a cohesive and efficient workflow across various applications and services.
Comparing to Humane Pin and Rabbit AI Devices
While devices like the Humane Pin and Rabbit AI offer innovative new form factors, they often rely heavily on cloud connectivity for AI functions. In contrast, the Surface’s NPU allows for faster, more secure local processing. This means tasks are completed quicker and more securely, as data doesn’t need to be sent to the cloud.
Conclusion: Embracing AI-Driven Innovation
Microsoft’s AI-enhanced Surface computer signifies a shift towards intelligent augmentation rather than just physical redesign. By embedding AI within existing devices, we unlock new potentials for efficiency, personalization, and functionality, setting a new standard for future tech innovations. This approach not only makes interactions with technology smarter and more intuitive but also emphasizes the importance of on-device processing power for a faster and more secure user experience.
For more information and to pre-order the new Surface laptops, visit Microsoft’s official store.
by Joche Ojeda | May 19, 2024 | A.I
OpenAI’s ChatGPT and Microsoft’s Copilot are two powerful AI tools that have revolutionized the way we interact with technology. While both are designed to assist users in various tasks, they each have unique features that set them apart.
OpenAI’s ChatGPT
ChatGPT, developed by OpenAI, is a large language model chatbot capable of communicating with users in a human-like way¹⁷. It can answer questions, create recipes, write code, and offer advice¹⁷. It uses a powerful generative AI model and has access to several tools which it can use to complete tasks²⁶.
Key Features of ChatGPT
- Chat with Images: You can show ChatGPT images and start a chat.
- Image Generation: Create images simply by describing them in ChatGPT.
- Voice Chat: You can now use voice to engage in a back-and-forth conversation with ChatGPT.
- Web Browsing: Gives ChatGPT the ability to search the internet for additional information.
- Advanced Data Analysis: Interact with data documents (Excel, CSV, JSON).
Microsoft’s Copilot
Microsoft’s Copilot is an AI companion that works everywhere you do and intelligently adapts to your needs. It can chat with text, voice, and image capabilities, summarize documents and web pages, create images, and use plugins and Copilot GPTs
Key Features of Copilot
- Chat with Text, Voice, and Image Capabilities: Copilot includes chat with text, voice, and image capabilities/
- Summarization of Documents and Web Pages: It can summarize documents and web pages.
- Image Creation: Copilot can create images.
- Web Grounding: It can ground information from the web.
- Use of Plugins and Copilot GPTs: Copilot can use plugins and Copilot GPTs.
Comparison of Mobile App Features
| Feature |
OpenAI’s ChatGPT |
Microsoft’s Copilot |
| Chat with Text |
Yes |
Yes |
| Voice Input |
Yes |
Yes |
| Image Capabilities |
Yes |
Yes |
| Summarization |
No |
Yes |
| Image Creation |
Yes |
Yes |
| Web Grounding |
No |
Yes |
What makes the difference, the action button for the iPhone
The action button on iPhones, available on the iPhone 15 Pro and later models, is a customizable button for quick tasks. By default, it opens the camera or activates the flashlight. However, users can customize it to perform various actions, including launching a specific app. When set to launch an app, pressing the action button will instantly open the chosen app, such as the ChatGPT voice interface. This integration is further enhanced by the new ChatGPT-4.0 capabilities, which offer more accurate responses, better understanding of context, and faster processing times. This makes voice interactions with ChatGPT smoother and more efficient, allowing users to quickly and effectively communicate with the AI.
 |
 |
The ChatGPT voice interface is one of my favorite features, but there’s one thing missing for it to be perfect. Currently, you can’t send pictures or videos during a voice conversation. The workaround is to leave the voice interface, open the chat interface, find the voice conversation in the chat list, and upload the picture there. However, this brings another problem: you can’t return to the voice interface and continue the previous voice conversation.
Microsoft Copilot, if you are reading this, when will you add a voice interface? And when you finally do it, don’t forget to add the picture and video feature I want. That is all for my wishlist.
by Joche Ojeda | May 15, 2024 | C#, dotnet, Linux, Ubuntu, WSL
Hello, dear readers! Today, we’re going to talk about something called the Windows Subsystem for Linux, or WSL for short. Now, don’t worry if you’re not a tech wizard – this guide is meant to be approachable for everyone!
What is WSL?
In simple terms, WSL is a feature in Windows that allows you to use Linux right within your Windows system. Think of it as having a little bit of Linux magic right in your Windows computer!
Why Should I Care?
Well, WSL is like having a Swiss Army knife on your computer. It can make certain tasks easier and faster, and it can even let you use tools that were previously only available on Linux.
Is It Hard to Use?
Not at all! If you’ve ever used the Command Prompt on your Windows computer, then you’re already halfway there. And even if you haven’t, there are plenty of easy-to-follow guides out there to help you get started.
Do I Need to Be a Computer Expert to Use It?
Absolutely not! While WSL is a powerful tool that many developers love to use, it’s also quite user-friendly. With a bit of curiosity and a dash of patience, anyone can start exploring the world of WSL.
As a DotNet developer, you might be wondering why there’s so much buzz around the Windows Subsystem for Linux (WSL). Let’s dive into the reasons why WSL could be a game-changer for you.
- Seamless Integration: WSL provides a full-fledged Linux environment right within your Windows system. This means you can run Linux commands and applications without needing a separate machine or dual-boot setup.
- Development Environment Consistency: With WSL, you can maintain consistency between your development and production environments, especially if your applications are deployed on Linux servers. This can significantly reduce the “it works on my machine” syndrome.
- Access to Linux-Only Tools: Some tools and utilities are only available or work better on Linux. WSL brings these tools to your Windows desktop, expanding your toolkit without additional overhead.
- Improved Performance: WSL 2, the latest version, runs a real Linux kernel inside a lightweight virtual machine (VM), which leads to faster file system performance and complete system call compatibility.
- Docker Support: WSL 2 provides full Docker support without requiring additional layers for translation between Windows and Linux, resulting in a more efficient and seamless Docker experience.
In conclusion, WSL is not just a fancy tool; it’s a powerful ally that can enhance your productivity and capabilities as a DotNet developer.
by Joche Ojeda | May 15, 2024 | Data Synchronization, EfCore
I’m happy to announce the new version of SyncFramework for EfCore, targeting net8.0 and referencing EfCore 8 nugets as follow
- EfCore Postgres Version: 8.0.4
- EfCore PomeloMysql Version: 8.0.2
- EfCore Sqlite Version: 8.0.5
- EfCore SqlServer Version: 8.0.5
You can download the new versions from Nuget.org and check the repo here
Happy synchronization everyone!!!!
by Joche Ojeda | May 14, 2024 | C#, Data Synchronization, dotnet
Hello there! Today, we’re going to delve into the fascinating world of design patterns. Don’t worry if you’re not a tech whiz – we’ll keep things simple and relatable. We’ll use the SyncFramework as an example, but our main focus will be on the design patterns themselves. So, let’s get started!
What are Design Patterns?
Design patterns are like blueprints – they provide solutions to common problems that occur in software design. They’re not ready-made code that you can directly insert into your program. Instead, they’re guidelines you can follow to solve a particular problem in a specific context.
SOLID Design Principles
One of the most popular sets of design principles is SOLID. It’s an acronym that stands for five principles that help make software designs more understandable, flexible, and maintainable. Let’s break it down:
- Single Responsibility Principle: A class should have only one reason to change. In other words, it should have only one job.
- Open-Closed Principle: Software entities should be open for extension but closed for modification. This means we should be able to add new features or functionality without changing the existing code.
- Liskov Substitution Principle: Subtypes must be substitutable for their base types. This principle is about creating new derived classes that can replace the functionality of the base class without breaking the application.
- Interface Segregation Principle: Clients should not be forced to depend on interfaces they do not use. This principle is about reducing the side effects and frequency of required changes by splitting the software into multiple, independent parts.
- Dependency Inversion Principle: High-level modules should not depend on low-level modules. Both should depend on abstractions. This principle allows for decoupling.
Applying SOLID Principles in SyncFramework
The SyncFramework is a great example of how these principles can be applied. Here’s how:
- Single Responsibility Principle: Each component of the SyncFramework has a specific role. For instance, one component is responsible for tracking changes, while another handles conflict resolution.
- Open-Closed Principle: The SyncFramework is designed to be extensible. You can add new data sources or change the way data is synchronized without modifying the core framework.
- Liskov Substitution Principle: The SyncFramework uses base classes and interfaces that allow for substitutable components. This means you can replace or modify components without affecting the overall functionality.
- Interface Segregation Principle: The SyncFramework provides a range of interfaces, allowing you to choose the ones you need and ignore the ones you don’t.
- Dependency Inversion Principle: The SyncFramework depends on abstractions, not on concrete classes. This makes it more flexible and adaptable to changes.
And that’s a wrap for today! But don’t worry, this is just the beginning. In the upcoming series of articles, we’ll dive deeper into each of these principles. We’ll explore how they’re applied in the source code of the SyncFramework, providing real-world examples to help you understand these concepts better. So, stay tuned for more exciting insights into the world of design patterns! See you in the next article!
Related articles
If you want to learn more about data synchronization you can checkout the following blog posts:
- Data synchronization in a few words – https://www.jocheojeda.com/2021/10/10/data-synchronization-in-a-few-words/
- Parts of a Synchronization Framework – https://www.jocheojeda.com/2021/10/10/parts-of-a-synchronization-framework/
- Let’s write a Synchronization Framework in C# – https://www.jocheojeda.com/2021/10/11/lets-write-a-synchronization-framework-in-c/
- Synchronization Framework Base Classes – https://www.jocheojeda.com/2021/10/12/synchronization-framework-base-classes/
- Planning the first implementation – https://www.jocheojeda.com/2021/10/12/planning-the-first-implementation/
- Testing the first implementation – https://youtu.be/l2-yPlExSrg
- Adding network support – https://www.jocheojeda.com/2021/10/17/syncframework-adding-network-support/
