yanashin-blog

[yanashin-blog]

RustRover 発表のまとめ

JetBrainsは、Rustプログラム向けに特化したスタンドアロンの統合開発環境（IDE）であるRustRoverを紹介しています。このIDEは、他のJetBrainsのIDEと同等の機能を提供する専用のIDEを求めるRustコミュニティからの要望に応えたものです

JetBrainsは、RustRover Early Access Program（EAP）を開始し、ユーザーにIDEを試してもらい、フィードバックを提供し、製品の開発に貢献してもらうことを歓迎しています。RustRoverは、パブリックプレビューの間は無料で提供され、商用リリースの日程に近づくにつれてライセンスモデルが確定します。

キーポイント:

RustRoverの紹介: JetBrainsは、Rustプログラム向けに特化したスタンドアロンの統合開発環境（IDE）であるRustRoverをリリースしました。

Rustサポートの経緯: JetBrainsは、RustサポートをIntelliJ IDEAとCLionの両方でプラグインとして統合するために数年間取り組んできました。しかし、JetBrainsの他のIDEと同等の機能を持つ、Rustに特化したIDEへの要望はコミュニティで持続的でした。

RustRover Early Access Program（EAP）: RustRover EAPに参加するユーザーを募集しています。JetBrainsはユーザーにRustRoverをテストし、フィードバックを提供し、製品の開発に積極的に参加してもらうことを奨励しています。パブリックプレビューの間、RustRoverは無料で提供され、商用リリースの前にライセンスモデルが確立されます。

商用IDE: RustRoverはEAP期間後に商用プランに移行します。RustRover内で提供する新機能の需要が増加しているため、商用モデルへの移行の決定が下されました。JetBrainsはRustサポートをさらに高めることを目指しています。

リリース日: JetBrainsは2024年9月までにRustRoverをリリースする予定です。

既存のオープンソースプラグイン: RustRoverの基盤となる既存のオープンソースのRustプラグインは、GitHubとマーケットプレイスで引き続き利用可能です。ただし、今後の開発作業はクローズドソースのRustRoverに集中されます。JetBrainsは新しいIDEバージョンとの互換性を維持しようと努力しますが、オープンソースプラグインのバグ修正や新機能の追加は行いません。

IntelliJ IDEAとCLionへのサポート: RustRoverの機能は、IntelliJ IDEA Ultimateのプラグインとしてインストールできます。プレビュー期間中は、このプラグインをCLionにインストールすることも可能です。ただし、RustRoverがリリースされた後、このプラグインが引き続き利用可能かどうかは未定です。ユーザーがプラグインを必要とするか、専用のRust IDEで十分かどうかはまだ確定していません。

JetBrainsがRust Foundationに参加: JetBrainsはRustエコシステムとコミュニティの成長を信じています。そうでなければIDEに賭けないでしょう。そのため、JetBrainsはRust Foundationに参加したことを嬉しく思っています。既存のメンバーと共に、JetBrainsはRustコミュニティの取り組みをサポートし、将来の開発を推進するお手伝いをします。

このRustRoverのリリースは、Rustコミュニティの要望に応え、Rustプログラマー向けに強化されたサポートと生産性を提供することを目指しています。

[yanashin-blog]

The concept of Forming, Storming, Norming and Performing (FSNP) describes the four stages of psychological development a team goes through as they work on a project. Teams move through each stage as they overcome challenges, learn to work together and eventually focus on accomplishing a shared goal.

Tuckman's stages of group development

[yanashin-blog]

Remote work requires communicating more, less frequently, because async communication involves less frequent, but richer communication. There is less talking about the work and more doing it, allowing the system to optimize for throughput and flow.

[yanashin-blog]

The advantage of Rust

Fast: Rust is a compiled language, which means that it is typically much faster than interpreted languages, such as Python and JavaScript.

Safe: Rust has a number of features that help to prevent memory errors, such as its borrow checker. This makes it a good choice for safety-critical applications.

Concurrent: Rust is well-suited for concurrent programming, thanks to its built-in support for threads and channels. This makes it a good choice for applications that need to handle multiple tasks at the same time.

Expressive: Rust has a rich syntax that allows for expressive and concise code.

Extensible: Rust is a very extensible language, with a large and active community of contributors. This means that there are a lot of libraries and tools available for Rust, and it is easy to add new features to the language.

Rust is a good choice for a variety of applications, including:

Systems programming: Rust is a popular choice for systems programming, such as writing operating systems and embedded systems software.

Web development: Rust is becoming a more popular choice for web development, thanks to its performance and safety features.

Game development: Rust is a good choice for game development, thanks to its concurrency features and its ability to create high-performance code.

Data science: Rust is a good choice for data science, thanks to its speed and its ability to handle large datasets.

[yanashin-blog]

I admit that Rust has a steep learning curve.

However, I think the appeal of Rust is that it still makes you think, "This language is worth learning".

[yanashin-blog]

We used to say "GIYF", Google Is Your Friend. But now I think it is unmistakably "GPT Is Your Friend"🤖.

[yanashin-blog]

Security is always important

Hey! What in the world is going on with Japan's cyber security!

I can't live in Japan without feeling safe!

I'm just now seeing this news, and I'm very angry.

📰 China hacked Japan’s sensitive defense networks, officials say

🔗 https://www.washingtonpost.com/national-security/2023/08/07/china-japan-hack-pentagon/

Now, I started writing a sentence from a comment that was suddenly rough.

However, I would like you to calm down and think about it. Japan may seem to have a high level of security awareness at first glance. But don't you think that is a defensive security?

For example, when developing a system, once something is created, it is not changed. Therefore, security problems caused by external factors due to changes are

security problems caused by external factors due to changes are often taken, right?

Yes, it is so-called "Shioduke (塩漬け)", mothballing.

The means of attack against computers are becoming more and more diverse. This is not for me to say now, but I think everyone understands this as an indisputable fact.

This is the result of this fact, although the government keeps saying that we need to focus on cybersecurity. I would like to see the government do what it says it will do.

Let me say something with a touch of irony. The Japanese government is always late. The Japanese government is always late.

Well, so much for the grand ironic ice-breaker, what I want to tell you today is this.

"Walls have ears. Doors have eyes. (壁に耳あり障子に目あり)"

I think everyone knows this famous proverb.

The term used to be used about conversations between people. But times have changed. We now live in a computer society. And these computers are connected to the world via the Internet. It is not too much to say that everything is exposed to the world.

This saying is true for your system and your computer.

Security is always important. And you can never lose money by taking too many security measures. It is too late after an incident has occurred. I hope that you will take measures as early as possible on any given day.

[yanashin-blog]

(๑•ᴗ•)φ... Slidev

It looks like a very good tool and I will use it next time.

[yanashin-blog]

It is no exaggeration to say that the history of software development is the history of software testing.

Since the advent of software, I am sure you are aware that we, the human race, have been working to improve quality in an effort to make things better.

By the way, when we look back on the history of mankind, we sometimes see the appearance of something that is a paradigm shift. For example, fire, and for example, electricity.

It is clear from history that the level of human culture changed dramatically before and after people learned how to use fire and electricity.

So what exactly is the paradigm shift in software development? What exactly is it that will be the fire and electricity for developers?

That is exactly what a Testcontainers is.

Software testing has long sought to improve efficiency in a variety of ways, and automation efforts have been encouraged. However, software is often affected by external factors, such as services external to the software, such as databases, message broker and etc.

In the past, software developers would work with infrastructure engineers to streamline the preparation of the development environment, for example.

Container technology and Testcontainers have created a paradigm shift that has changed the way software development and testing is done. Software developers themselves can now use databases and other environments as containers from the source code. It creates the environment on demand, when it is needed, and disposes of it neatly when it is no longer needed.

It is truly a Developer Experience itself, isn't it?

I would like to thank you for this wonderful project. I would also like to send my encouragement and support for the further development of this project.

And I am honored to have been chosen as a champion.

[yanashin-blog]

Pointer

A pointer is a general concept of a variable that contains a memory address.

If you are familiar with languages such as C/C++, you are probably familiar with it.

This "address" thingy refers or points to some other data.

Smart Pointer

A smart pointer is a pointer type that can dereference (refer to by *) a memory address,

In contrast, a smart pointer is a pointer type that can dereference a memory address (referenced by *) and has its own special capabilities.

In Rust, various smart pointers exist in the standard library.

Typical examples of smart pointers are

String : holds a valid UTF8 array as a Vec of guaranteed bytes

Vec : resizable array

Box : Allocates a value to the heap

Rc/Arc : Multiple owners by reference count

Cell/RefCell : Ability to make an invariant object variable

Cell/RefCell : has the ability to make an invariant object variable.

Stack & Heap

Stack

A memory area allocated at Rust process startup to hold data in a structure.

It can contain elements of any size in LIFO format (last element in, first element out).

It can contain elements of any size.

The only operations possible are push (adding an element to the stack) and pop (removing an element from the stack).

The stack consists of a stack frame (also called an allocation record) and data.

The stack frame is created with the execution of a function,

The stack frame is created when the function is executed and reflects the address that points to the current stack frame.

This is called the stack pointer.

The stack pointer is decremented each time a function is called within a function and is incremented by returning from the function,

It is incremented by returning from the function. When the system stack frame is exhausted, a stack overflow occurs,

stack overflow occurs.

Heap

The heap is a memory area for types whose size is unknown at program compilation time.

To allocate memory, the OS is asked to allocate it,

It is slower than the stack, but its capacity is larger than the stack.

Variable-size data such as Vec, String, and Box are stored in the heap.

Also, data in the heap must be accessed by pointers.

Box

Box is a simple smart pointer. Once the Box type is created, any value can be assigned to the heap.

let foo:Box<i32> = Box::new(1);

Box is a smart pointer to a value allocated on the heap. Exiting the target scope destroys the object and frees memory.

let x:i32 = 1; //Stack let y:Box<i32> = Box::new(2); //Heap println!("x + y = {}", x + *y);

Cell/RefCell

Cells, like Boxes described earlier, are objects that can be wrapped with any type. The difference is that it provides get and set methods.

let foo : Cell<i32> = Cell::new(100); foo.set(200); println!("foo : {}", foo.get());

It can update the value of a variable that is not muted and shares the same state. Cells with amazing functionality, though,

References in Cell are unretrievable.

Types in Cell must be implemented with Copy Trait.

Cannot be exchanged by multiple threads.

There are severe limitations, such as the inability to interact with multiple threads. In such cases, RefCell, which has slightly looser restrictions than Cell, seems to be a good choice.

RefCell is OK as long as the type inside implements Sized, and the reference inside can also be retrieved. However, the get/set that existed in Cell does not exist, RefMut method that returns RefMut must be used.

[yanashin-blog]

This is the last release that will support the hyperkit driver on macOS. This version includes a way to migrate existing Hyperkit-based Multipass instances to Qemu-based Multipass instances. Simply issuing:

$ multipass set local.driver=qemu

is enough to migrate the Hyperkit instances. Also, please follow the instructions given at the multipass client command line.Important Note: Along with this, Apple dropped support for macOS 10.15 on September 12, 2022, so this will be the last Multipass minor release supporting macOS 10.15, ie, version 1.13 will only support macOS 11 and newer.

[yanashin-blog]

Refactoring the developer's mindset for success

Start from Empathy

Let go of your Ego

Embrace change

Be curious

[yanashin-blog]

Did you know that when Platform Engineering started getting a lot of attention, at the same time the message "DevOps is dead" was spreading?

Over the next year, people from all over the world have been discussing DevOps and Platform Engineering.

And in a nutshell, DevOps is still alive. I believe that Platform Engineering and DevOps have the same essential purpose. I think it is fair to say that the discipline as Platform Engineering has been fostered based on the feedback from the insights and pain we have gained through DevOps practices.

I won't mention here today the discussion and history of the dead or alive of DevOps. I would like to write about it elsewhere. Today, I would like to talk a little about my thoughts on DevOps and xOps, which form the basis of Platform Engineering.

I mentioned earlier that the goal of DevOps is essentially the same as that of Platform Engineering. So what is its purpose? It is to make the developer's work more efficient and to optimize the entire development lifecycle.

In addition to DevOps, there are many other "xOps" disciplines that combine Ops with domains different from Dev, such as DevSecOps, BizOps, MLOps, and DataOps etc.

What makes DevOps different from DevOps is that each domain handles a different mission, so a simple comparison is not possible. However, if I were to point out some commonalities, I would say that they are, as mentioned above, to improve the efficiency of a particular domain.

For example, if you are primarily engaged in data work, the operations are related to "Data" related tasks. Similarly, if you are involved in "AI" or "ML", it is operations related to data collection, model learning, and its evaluation.

I believe that the reason xOps is getting so much attention is because there is a literal need to optimize Ops, which in turn improves the efficiency of engineers.

And it is engineering capabilities that are required to improve Ops. Engineering can automate each operation, create tools, and otherwise make it more efficient.

Then, the idea may arise that the engineer should do all the operational work. However, this is a mistake. Operations should be performed by operations staff. Engineers in each domain should focus on the mission of each domain. By taking an interest in and understanding the operations that occur to accomplish the work in their domain, engineers can see where the bottlenecks are. This is where engineering can make improvements. This allows us to optimize the entire process.

And never forget, as I mentioned earlier, not to create full-stack engineers where the engineer does everything. The existence of a large number of full-stack engineers may possibly be an unhealthy situation. The load may be too concentrated on one person. In other words, there is a risk of that becoming a new bottleneck.

That said, it might be fair to say that platforms are increasingly required to avoid raising certain loads and to avoid creating cognitive loads.

[yanashin-blog]

Excellent summary of the current state of LLMs

Models Include:

GPT-3.5

GPT-4

Code Interpreter/Plugins

Bard

Claude 2

Bing (GPT-4 with Internet)

[yanashin-blog]

Definition of Platform Engineering

Platform engineering aims to implement a self-service, in-house developer platform with the goal of increasing developer productivity by reducing cognitive load and abstracting complexity from the underlying infrastructure.

Platform characteristics and capabilities are typically defined by assessing the needs of the engineering team in delivering the software.

Platform engineering emerged as a solution to the challenges posed by DevOps, which promoted a high degree of automation but left organizations stagnant with scattered tools and processes.

Platform engineering puts control in the hands of platform teams rather than in the hands of individual developers. These teams maintain the platform by treating it as a product, assessing the needs of developers across the organization, and creating internal self-service tools suitable for most users.

These efforts may include other features such as Kubernetes abstraction, secret management handling, and container orchestration.

Platform engineering has the following advantages

✅ Improved developer experience: Significantly improves the developer experience for software build and release systems, improving the developer experience and smoothing software delivery. ✅ Standardize DevOps Practices: By integrating common DevOps principles into a shared platform, organizations can begin to standardize with reusable build processes and automated infrastructure. This unification can accelerate the adoption of DevOps practices across the organization. ✅ Protecting the DevOps pipeline: The various vulnerabilities present in modern CI/CD chains and cloud-native open source software can be mitigated by outsourcing DevOps responsibilities to a shared platform team. This approach allows organizations to coalesce around more secure practices and avoid missing critical updates and vulnerabilities. ✅ Provide additional guardrails: The platform team can also assist in acquiring new tools and developing and enforcing policies for the software infrastructure. While this may limit customization, additional guardrails can prevent shadow IT and strengthen governance over internal development.

DevOps and Platform Engineering: A Brief Comparison

DevOps and platform engineering both aim to make software development and deployment more efficient, but they differ in their approach, mindset, tool selection, and focus.

DevOps is an approach to software development with a project-based mindset, where developers often choose their own tools; DevOps teams typically focus on providing the cloud infrastructure necessary for developers to run applications at various stages of The emphasis is on providing the cloud infrastructure necessary for developers to run the application at various stages.

Platform engineering, on the other hand, is the act of building a single platform for DevOps tools and workflows with a product mindset. Platform engineering focuses solely on providing the tools and workflows necessary to enable a seamless developer experience across the entire application lifecycle. They are also responsible for maintaining and extending the platform over time.

[yanashin-blog]

Amazon Chief Technology Officer Werner Vogels’ dictum “you build it, you run it”

DevOps was not simply a new way of delivering software. It brought a whole new way of thinking about our roles as individuals within a team and how we interact with those around us.

“you build it, you run it” emerged on the scene as a whole new way of thinking.

The Limits of DevOps

But that was a long time ago. The world has changed, and with it, the reality of systems development in the 2000s began to look dated and out of step with the era of increasingly complex and highly distributed software systems.

This increased complexity has created new challenges in the way software is built and deployed. From a team and organizational perspective, it places new stresses and burdens on the people actually doing the work. It also leads to the production of cognitive load.

What the result actually brings is massive burnout.

Specialization is not a bad thing when the tool chain is very complex. Specialization does not mean siloing.

When specialization removes barriers, it blurs who is in charge of what.

So how do we clarify those boundaries? The key is how to increase specialization so that people can focus on what they do best.

This is where platform engineering comes in.

The rise of Platform Engineering

How does platform engineering clarify the boundary between developers and operations personnel? With platform engineering building the IDP, the operations department can configure the infrastructure and focus on the actual operations and infrastructure issues. On the other hand, developers will be able to self-serve and not have to bother the operations department. Also, the operations department will no longer have to worry about repetitive requests from developers.

[yanashin-blog]

What Comes After Kubernetes?

✅Native Scale to Zero ✅Smaller API Surface ✅Configuration Language ✅Orchestration for {WebAssembly, Functions, something else}

I still feel that a PaaS-like platform characterized by ease and simplicity is long overdue.