Microservices for building an IDE - The innards of JetBrains Rider - NDC Oslo 2020

The document summarizes key concepts about the Android application model including application components, intents, activities and tasks, processes and threads, and component lifecycles. It explains that an Android application consists of fundamental components like activities, services, broadcast receivers and content providers. Activities display the user interface, services run in the background, broadcast receivers respond to system-wide broadcasts, and content providers manage shared data.

Dan Morrill discusses the different ways to code applications for Android, including managed Dalvik code, Ajax/web apps, and native code. He outlines what each approach is capable of and not capable of. He demonstrates k-means clustering implemented in each approach. Morrill concludes that there are benefits to different approaches and developers should choose based on their app's specific needs and the developer's skills.

A look at how Rider, a new .NET IDE from JetBrains, uses IntelliJ to provide a cross platform, fully featured UI for ReSharper.

Доклад Антона Минашкина для Съесть собаку #15, 27/11/18 Тезисы: - Почему DI – такой популярный design pattern в Android; - Что особенного в DI для Kotlin; - Практическая польза и опции DI.

The document provides an overview of the Java programming language. It discusses that Java was developed in the early 1990s by Sun Microsystems. It then summarizes some of Java's main features, including that it is a simple, object-oriented, robust, distributed, platform independent, secured, architecture-neutral, portable, high-performance, multi-threaded, and dynamic language. It also briefly discusses the Java Virtual Machine, Java Runtime Environment, Java Development Kit, Java bytecode, and the main method.

Protocol Buffers are a language-neutral, platform-neutral mechanism for serializing structured data. They can be used to define interfaces for APIs and exchange data between systems. Protocol Buffers include a data definition language to define message types, a serialization format to encode structured data in a compact binary form, and code generation plugins to generate data access code in multiple languages. Protocol Buffers provide a flexible and efficient method for serializing structured data for storage or network transmission.

This academic article discusses integrating Java applications with C/C++ implementations using the Java Native Interface (JNI). It describes developing JNI code with IBM WebSphere Integration Developer. The key steps are: 1. Create a Java class with methods to expose to native code. Compile to generate a C header file. 2. Implement the native methods in a shared library, allowing calls to other C APIs. 3. Configure the shared library in the WebSphere runtime. This allows integrating existing C/C++ applications like scientific software with Java programs through the JNI bridge in an enterprise environment.

Ever wondered how IDE’s are built? In this talk, we’ll skip the marketing bit and dive into the architecture and implementation of JetBrains Rider. We’ll look at how and why we have built (and open sourced) a reactive protocol, and how the IDE uses a “microservices” architecture to communicate with the debugger, Roslyn, a WPF renderer and even other tools like Unity3D. We’ll explore how things are wired together, both in-process and across those microservices. Let’s geek out!

Ever wondered how IDE’s are built? In this talk, we’ll skip the marketing bit and dive into the architecture and implementation of JetBrains Rider. We’ll look at how and why we have built (and open sourced) a reactive protocol, and how the IDE uses a “microservices” architecture to communicate with the debugger, Roslyn, a WPF renderer and even other tools like Unity3D. We’ll explore how things are wired together, both in-process and across those microservices. Let’s geek out!

Ever wondered how IDE’s are built? In this talk, we’ll skip the marketing bit and dive into the architecture and implementation of JetBrains Rider. We’ll look at how and why we have built (and open sourced) a reactive protocol, and how the IDE uses a “microservices” architecture to communicate with the debugger, Roslyn, a WPF renderer and even other tools like Unity3D. We’ll explore how things are wired together, both in-process and across those microservices. Let’s geek out!

The document is a presentation about Silverlight 2 for developers. It includes an agenda covering CRUD, designers, patterns and testing. It discusses using Silverlight 2 for building applications with a dive log app as an example. It covers using services, securing applications, HTTP requests and using Blend. It also discusses using MVC patterns, separation of concerns, the presentation model pattern and implementing data binding, commands and value converters in applications.

This document provides an overview of new features and enhancements in Visual Studio 2005, also known as Whidbey. It summarizes improvements to languages like Visual Basic .NET, Visual C#, C++, and Visual J#, the .NET Framework, data access, web services, and mobile development. Key areas of focus include increased productivity, simplified development, and better integration across languages, frameworks, and platforms.

The document discusses the C/C++ Development Tools (CDT) plugin for Eclipse, including what the CDT is used for, how it parses code and generates an abstract syntax tree (AST) to facilitate code analysis and refactoring, and how the CDT uses an index to improve parsing performance for large projects.

This document summarizes a presentation on Microsoft .NET and C#. It discusses .NET as a set of technologies for connecting information and as an emphasis on web services. C# is presented as a language that combines the safety of Java, ease of Visual Basic, and power of C++. Key aspects of .NET like the Common Language Runtime and class libraries are defined. The document also provides a brief comparison between .NET and J2EE frameworks and languages.

The document discusses HTML5 as a platform for user interfaces. It outlines several new features of HTML5, including the <canvas> element for drawing, WebGL for 3D graphics, multi-touch support, local storage with Web SQL databases, real-time updates with Web Sockets, improved file handling, and offline application caching. The document argues that HTML5 provides many of the capabilities of native applications and recommends using HTML5 and JavaScript for cross-platform user interface development.

This document provides an overview of Visual Basic .NET, including an introduction to the .NET framework, Visual Studio integrated development environment, VB.NET language basics like variables, data types, operators, arrays, and enumerations. It concludes with details on creating a simple "Hello World" console application in VB.NET.

Framework design involves balancing many considerations, such as: - Managing dependencies between components to allow for flexibility and evolution over time. Techniques like dependency injection and layering help achieve this. - Designing APIs by first writing code samples for key scenarios and defining object models to support these samples to ensure usability. - Treating simplicity as a feature by removing unnecessary requirements and reusing existing concepts where possible.

This is the slide deck I presented at the recent MSDN Events series showcasing Visual Studio 2010, .NET 4, and SharePoint 2010 for Developers.

Software development has shifted focus from efficiency to productivity, reusability, and user-friendliness. Object-oriented programming (OOP) models objects that contain data and methods. Key OOP concepts include inheritance, where subclasses extend and modify superclass features. An integrated development environment (IDE) combines tools like editors, compilers, linkers, and debuggers. Java uses a hybrid approach of compiling to bytecode, then interpreting for platform independence. Console applications use text input/output. Graphical user interface (GUI) applications use menus and buttons. Applets run in web browsers.

This document summarizes a presentation on building VSTO applications using LINQ. The presentation covers the fundamentals of VSTO development, how and why to use LINQ, and includes demos. Reasons for using VSTO over VBA are discussed, as well as how to add LINQ to a VSTO application.

Visual Studio 2010 includes many new features to improve the developer experience such as breakpoint grouping, parallel debugging tools, and a more extensible architecture. It can be used both as a robust code editor and as a platform for extensions. .NET 4.0 focuses on four main areas: better component integration, improved performance through parallelism and concurrency, enhanced language features, and reducing bugs. It includes new libraries like PLINQ and TPL for parallel programming and MEF for extensibility.

At this current time, HTML5 APIs are mature enough so that the web browser can now be a very good platform for applications that were before only implemented as native applications : offline applications with locally stored data, embedded SQL engines, etc. Although there are many good Javascript frameworks out there, the Java language allows to build, maintain, debug and work with ease on really big applications (> 100,000 LOC). You'll discover in this presentation all the tools we assembled to make an application available with its data 100% of the time, even without internet!

This document provides an overview and summary of the Android deep dive presentation given by Marko Gargenta at Sprint Dev Con 2010. It discusses the Android stack including the Linux kernel, native libraries like WebKit and SQLite, the Dalvik VM, and the application framework. It also covers building a basic "Hello World" Android app, common app components like activities, services, content providers and broadcasts receivers. The document summarizes the Android user interface approach using XML layouts and views, and operating system features such as security, files system, and cloud integration.

The document provides an overview of the iOS development platform. It describes the core components of iOS including Cocoa Touch, Core OS, Core Services, and Media frameworks. It explains concepts like the Model-View-Controller pattern and the iOS application structure and life cycle. Key topics like Objective-C classes, methods, properties, dynamic binding, and common frameworks like Foundation are also summarized.

This document provides an overview and introduction to developing applications for the Windows 8 platform. It covers WinRT basics, best practices for architecture and patterns like MVVM, using pickers and contracts to integrate app functionality, tiles and notifications for live updates and notifications, and resources for further information.

Instead of asking people which JavaScript framework to learn, let's look back into GUI application architecture (which Web Front-end is a case). Then you will understand why people created those library & frameworks and why React became so popular.

Lars Vogel gives an overview of Android programming. Android uses the Java programming language but runs applications on the Dalvik virtual machine instead of the Java Virtual Machine. The main Android programming constructs are activities, views, intents, broadcast receivers, services, and content providers. Activities provide user interfaces, services run in the background, and broadcast receivers listen for system events.

The C# nullability features help you minimize the likelihood of encountering that dreaded System.NullReferenceException. Nullability syntax and annotations give hints as to whether a type can be nullable or not, and better static analysis is available to catch unhandled nulls while developing your code. What's not to like? Introducing explicit nullability into an existing code bases is a Herculean effort. There's much more to it than just sprinkling some `?` and `!` throughout your code. It's not a silver bullet either: you'll still need to check non-nullable variables for null. In this talk, we'll see some techniques and approaches that worked for me, and explore how you can migrate an existing code base to use the full potential of C# nullability.

After buying a set of Sonos-compatible speakers at IKEA, I was disappointed there's no support for playing audio from a popular video streaming service. They stream Internet radio, podcasts and what not. Well, not that service I want it to play! Determined - and not knowing how deep the rabbit hole would be - I ventured on a trip that included network sniffing on my access point, learning about UPnP and running a web server on my phone (without knowing how to write anything Android), learning how MP4 audio is packaged (and has to be re-packaged). This ultimately resulted in an Android app for personal use, which does what I initially wanted: play audio from that popular video streaming service on Sonos. Join me for this story about an adventure that has no practical use, probably violates Terms of Service, but was fun to build!

Space is a team tool that integrates chats, meetings, git hosting, automation, and more. It has an HTTP API to integrate third party apps and workflows, but it's massive! And slightly opinionated. In this session, we will see how we built the .NET SDK for Space, and how we make that massive API more digestible. We will see how we used code generation, and incrementally made the API feel more like a real .NET SDK.

Which NuGet package was that type in again? In this session, let's build a "reverse package search" that helps finding the correct NuGet package based on a public type. Together, we will create a highly-scalable serverless search engine using Azure Functions and Azure Search that performs 3 tasks: listening for new packages on NuGet.org (using a custom binding), indexing packages in a distributed way, and exposing an API that accepts queries and gives our clients the best result.

This document discusses .NET memory management and the garbage collector. It explains that the CLR manages memory in a heap and the garbage collector reclaims unused memory. It describes how objects are allocated in generations and discusses how to help the garbage collector perform better by reducing allocations, using value types when possible, and properly disposing of objects. The document also provides examples of hidden allocations and demonstrates tools for analyzing memory usage like ClrMD and dotMemory Unit.

Which NuGet package was that type in again? In this session, let's build a "reverse package search" that helps finding the correct NuGet package based on a public type. Together, we will create a highly-scalable serverless search engine using Azure Functions and Azure Search that performs 3 tasks: listening for new packages on NuGet.org (using a custom binding), indexing packages in a distributed way, and exposing an API that accepts queries and gives our clients the best result. https://blog.maartenballiauw.be/post/2019/07/30/indexing-searching-nuget-with-azure-functions-and-search.html

Which NuGet package was that type in again? In this session, let's build a "reverse package search" that helps finding the correct NuGet package based on a public type. Together, we will create a highly-scalable serverless search engine using Azure Functions and Azure Search that performs 3 tasks: listening for new packages on NuGet.org (using a custom binding), indexing packages in a distributed way, and exposing an API that accepts queries and gives our clients the best result.

Which NuGet package was that type in again? In this session, let's build a "reverse package search" that helps finding the correct NuGet package based on a public type. Together, we will create a highly-scalable serverless search engine using Azure Functions and Azure Search that performs 3 tasks: listening for new packages on NuGet.org (using a custom binding), indexing packages in a distributed way, and exposing an API that accepts queries and gives our clients the best result.

Speaking from experience building a SaaS: users are insane. If you are lucky, they use your service, but in reality, they probably abuse. Crazy usage patterns resulting in more requests than expected, request bursts when users come back to the office after the weekend, and more! These all pose a potential threat to the health of our web application and may impact other users or the service as a whole. Ideally, we can apply some filtering at the front door: limit the number of requests over a given timespan, limiting bandwidth, ... In this talk, we’ll explore the simple yet complex realm of rate limiting. We’ll go over how to decide on which resources to limit, what the limits should be and where to enforce these limits – in our app, on the server, using a reverse proxy like Nginx or even an external service like CloudFlare or Azure API management. The takeaway? Know when and where to enforce rate limits so you can have both a happy application as well as happy customers.

This document discusses indexing NuGet packages using Azure Functions and Azure Search to power search capabilities in ReSharper and Rider. It proposes using Functions triggered by changes to the NuGet.org catalog to download packages, index them using reflection metadata, and upload the results to an Azure Search index. Each step would be a separate function to allow independent scaling. The final system would watch the catalog, index new/updated packages, and provide APIs for searching packages by type or namespace.

Speaking from experience building a SaaS: users are insane. If you are lucky, they use your service, but in reality, they probably abuse. Crazy usage patterns resulting in more requests than expected, request bursts when users come back to the office after the weekend, and more! These all pose a potential threat to the health of our web application and may impact other users or the service as a whole. Ideally, we can apply some filtering at the front door: limit the number of requests over a given timespan, limiting bandwidth, ... In this talk, we’ll explore the simple yet complex realm of rate limiting. We’ll go over how to decide on which resources to limit, what the limits should be and where to enforce these limits – in our app, on the server, using a reverse proxy like Nginx or even an external service like CloudFlare or Azure API management. The takeaway? Know when and where to enforce rate limits so you can have both a happy application as well as happy customers.

The .NET Garbage Collector (GC) is really cool. It helps providing our applications with virtually unlimited memory, so we can focus on writing code instead of manually freeing up memory. But how does .NET manage that memory? What are hidden allocations? Are strings evil? It still matters to understand when and where memory is allocated. In this talk, we’ll go over the base concepts of .NET memory management and explore how .NET helps us and how we can help .NET – making our apps better. Expect profiling, Intermediate Language (IL), ClrMD and more!