Version 1.97 of @code is out now with Copilot Next Edit Suggestions, Python no-config debugging, SVG image preview, and more!
Full release notes: https://t.co/4rvuV30QGW
Here are some of the highlights… 🧵
This is the fastest I've seen Llama 3.3 running anywhere!
Llama 3.3 70B running at 652 t/s is lightning fast.
And if you want Llama 3.1, here are the speeds I was able to get:
• Llama 3.1 8B: 1006 t/s
• Llama 3.1 70B: 709 t/s
• Llama 3.1 405B: 206 t/s
(You can access all of these models for free! See the link below.)
This speed is incredible, but the interesting part is what's happening behind the scenes:
These models aren't running on a GPU!
In this video, I'm using the SambaNova cloud to access these models. They built a custom chip (SN40L) optimized for AI workflows.
A single SN40L chip can hold hundreds of models (trillions of parameters) in memory!
The speed alone is a huge deal, but the big advantage is for agentic workflows running multiple specialized models.
A GPU can only host a single model and switch (unload and load) to a different model if necessary. An SN40L, on the other hand, can host every model at once, making it much faster.
Here is the video where you can see how fast these chips are:
ACID in Databases stands for Atomicity, Consistency, Isolation, and Durability.
✅ Atomicity (A)
Atomic means something that cannot be broken down.
Atomicity describes what happens to a Transaction that’s executing multiple write operations and something goes wrong halfway.
Think of a Transaction as a bridge between two states of data named A and B.
No intermediate states are allowed.
It’s all or nothing.
So, if you can’t complete the entire transaction successfully, you don’t complete any part of it.
The transaction is completely aborted.
Without atomicity, a mid-way error during multiple updates, the entire database state can turn into a mess.
Retrying the transaction would be risky because it can result in duplicate data.
Atomicity saves you from all this trouble.
✅ Consistency (C)
Consistency in ACID is all about the context of your application.
In any application or system, some statements must be true.
For example, credits and debits in a bank must always be balanced.
A consistent transaction is one where statements are true at the beginning as well as the end of the transaction.
But most of it depends on your application.
A database cannot save you if you write bad data that violates the invariants.
Sure, you can have some checks like foreign keys or constraints but a lot of it depends on the application’s requirements.
So - when you think about it, Consistency is the property of your application.
✅ Isolation (I)
Isolation is the trickiest guarantee.
It’s a given that your database will be accessed by multiple clients at the same time.
Databases can handle this quite well if they are reading and writing different parts of the database.
But the plot thickens when different clients try to access the same database records.
This ends up creating concurrency issues.
An example of this issue is two clients simultaneously trying to increment a counter that is stored in a database.
Despite two increment requests, the counter was only incremented by 1 because of race conditions.
The goal of Isolation is that concurrently executing transactions are isolated from each other.
But it’s more of a degree than an absolute value.
There are multiple isolation levels ranging from weak to strong.
✅ Durability (D)
Lastly, the purpose of a database system is to let you store data without any fear of losing it.
Durability is the guarantee that promises this safety.
The guarantee holds even in case of a hardware fault or database crash.
There are two ways databases achieve this:
- Disk storage and write-ahead logs for single-node databases
- Replication for multiple nodes.
Of course, there is no perfect durability. It’s all about risk-reduction techniques.
So - what do you think about ACID guarantees?
How do you design a good API?
Here are 5 tips for designing a quality API.
API design is deciding how your API will expose data and functionality to consumers. A good API design describes the API endpoints and resources in some standard format.
There are 4 key stages of API design:
1 - Determine what the API should do
2 - Define the API contracts (OpenAPI)
3 - Validate your assumptions with tests
4 - Document the API (endpoints, error codes, etc.)
Here are 5 more tips for designing a good API.
1) 𝗣𝗿𝗶𝗼𝗿𝗶𝘁𝗶𝘇𝗲 𝗖𝗼𝗻𝘀𝗶𝘀𝘁𝗲𝗻𝗰𝘆 𝗮𝗻𝗱 𝗦𝗶𝗺𝗽𝗹𝗶𝗰𝗶𝘁𝘆
Your API should have consistent naming conventions, response formats, and an error-handling strategy. Simplicity in API design makes it easier for developers to understand and integrate with your API.
2) 𝗘𝗺𝗯𝗿𝗮𝗰𝗲 𝗥𝗘𝗦𝗧𝗳𝘂𝗹 𝗣𝗿𝗶𝗻𝗰𝗶𝗽𝗹𝗲𝘀
You should design your API according to RESTful principles, emphasizing statelessness, a client-server architecture, and a uniform interface. REST APIs are the standard in most .NET applications.
3) 𝗨𝘀𝗲 𝘁𝗵𝗲 𝗰𝗼𝗿𝗿𝗲𝗰𝘁 𝗛𝗧𝗧𝗣 𝗦𝘁𝗮𝘁𝘂𝘀 𝗖𝗼𝗱𝗲𝘀
You should use the correct HTTP status codes to communicate the outcome of API requests. This includes successful operations (2xx), client errors (4xx), and server errors (5xx). It helps consumers of your API understand what went wrong and how to rectify it.
4) 𝗜𝗺𝗽𝗹𝗲𝗺𝗲𝗻𝘁 𝗔𝗣𝗜 𝗩𝗲𝗿𝘀𝗶𝗼𝗻𝗶𝗻𝗴
Plan for future changes by implementing versioning in your API. This allows you to make improvements and changes without breaking existing client integrations. The most common approach is URL versioning.
5) 𝗔𝘂𝘁𝗵𝗡 𝗮𝗻𝗱 𝗔𝘂𝘁𝗵𝗭
Implement authentication, authorization, and data encryption where necessary. Protecting sensitive data and ensuring that only authorized users can access specific API endpoints is crucial for maintaining the trust and integrity of your API.
If you liked this, consider joining 48,000+ engineers in The .NET Weekly.
✅ One practical tip every Saturday
✅ .NET best practices and actionable advice
✅ Software Architecture deep dives and fresh ideas
Subscribe here → https://t.co/IAdIqoDe37
What is something you do to design a good API?
DevOps engineer toolkit🧰🎒
Operating system → Linux (recommended), Windows
Programming → Go, Python, Groovy, Bash
Container orchestration → Kubernetes, Docker Swarm
Containers → Docker, Podman, Containerd
Source Code Management → Git, Subversion
Cloud → AWS, GCP, Azure, CivoCloud
CI/CD → Jenkins, CircleCI, Bamboo
Source control and collaborative coding → GitHub, BitBucket, GitLab
IaC (Infrastructure as Code) and IP (Infrastructure Provisioning) → Ansible, Puppet, Chef, Terraform, Pulumi, Stack, Crossplane
Continuous Feedback → GetFeedback, Jira, Slack, Pendo
Observability (monitoring, logging, and analyzing system behavior) → Nagios, Grafana , Prometheus, New Relic, ELK Stack Datadog
Plan → Jira Software, Confluence, Slack
Automated testing → xray, snyk, JUnit, Selenium, Appium
You can choose any of those tools for each phase/category. Your choice may be based on your project or organization, or it may be entirely personal.
Learn slowly, step by step, and never stop learning.
If you found this thread valuable:
1. Toss me a follow (@thatstraw) for more daily content on DevOps, linux and sysadmin.
2. Like and Repost so other DevOps folks can find it too.
Top 10 Hacking And CyberSecurity Course For FREE
Link 1 :https://t.co/cALvxHrPmk
link 2 :https://t.co/y6vrTnJAWr
link 3 :https://t.co/sElVczZoFd
link 4 :https://t.co/tMstxikSku
link 5 :https://t.co/lv4PSWCU8R