Category: adces

Introduction in Roslyn Code Generators & Building Your Own Search Assistant

Azi la 19:30 avem o noua intilnire ADCES

Presentation 1 : Introduction in Roslyn Code Generators
Description:
Presenter : Ignat Andrei, http://msprogrammer.serviciipeweb.ro/
Presentation 2: # Building Your Own Search Assistant: A Hands-On Guide to Internet-Connected AI Tools
Description:
Ever marveled at Microsoft’s Copilot knack for discussing up-to-the-minute topics, despite being trained on data up to only September 2021? Curious about the magic that goes on under the hood?
Join Vlad as he peels back the curtain on the innovative techniques used to create a search assistant that can converse about current events. This interactive session will guide you through the entire process, exploring methods like fine-tuning, retrieval augmented generation, and tackling challenges such as slow model inference and context window limitations.
Expect a live demonstration of a simple yet effective application and walk away with the knowledge to craft your very own assistant using just Python, pandas, and the Azure OpenAI APIs. Don’t miss the chance to move from concept to code in this practical deep dive!

Presenter: Vlad Iliescu, https://vladiliescu.net/

Va astept aici: https://www.meetup.com/bucharest-a-d-c-e-s-meetup/events/298422420/

RSCG – Architect.DomainModeling

RSCG – Architect.DomainModeling
 
 

name Architect.DomainModeling
nuget https://www.nuget.org/packages/Architect.DomainModeling/
link https://github.com/TheArchitectDev/Architect.DomainModeling
author Timo van Zijll Langhout

Domain Modelling -DDD, Entity and more. Here I will show just the builder

 

This is how you can use Architect.DomainModeling .

The code that you start with is


<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net8.0</TargetFramework>
	  <Nullable>enable</Nullable>
  </PropertyGroup>

	  <PropertyGroup>
        <EmitCompilerGeneratedFiles>true</EmitCompilerGeneratedFiles>
        <CompilerGeneratedFilesOutputPath>$(BaseIntermediateOutputPath)\GX</CompilerGeneratedFilesOutputPath>
    </PropertyGroup>

	  <ItemGroup>
	    <PackageReference Include="Architect.DomainModeling" Version="3.0.2" />
	  </ItemGroup>

	 

</Project>


The code that you will use is


using Builder;

var pOld = new Person("Andrei", "Ignat");
pOld.MiddleName = "G";
var build = new PersonBuilder()
    .WithFirstName(pOld.FirstName)
    //.WithMiddleName("") // it is not into the constructor
    .WithLastName(pOld.LastName)
    ;
    
var pNew = build.Build();
System.Console.WriteLine(pNew.FullName());
System.Console.WriteLine(pOld.FullName());



namespace Builder;
public class Person
{
    
    public Person(string firstName, string lastName)
    {
        FirstName = firstName;
        LastName = lastName;
    }
    public string FirstName { get; set; }
    public string? MiddleName { get; set; }
    public string LastName { get; set; }

    public string FullName()
    {
        return FirstName + " " + MiddleName + " "+LastName;
    }
    
}



using Architect.DomainModeling;

namespace Builder;

[DummyBuilder<Person>]
public partial class PersonBuilder
{
}

 

The code that is generated is

using System;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;

#nullable disable

namespace Builder
{
	/// <summary>
	/// <para>
	/// Implements the Builder pattern to construct <see cref="Builder.Person"/> objects for testing purposes.
	/// </para>
	/// <para>
	/// Where production code relies on the type's constructor, test code can rely on this builder.
	/// That way, if the constructor changes, only the builder needs to be adjusted, rather than lots of test methods.
	/// </para>
	/// </summary>
	/* Generated */ public partial class PersonBuilder
	{
		private string FirstName { get; set; } = "FirstName";
		public PersonBuilder WithFirstName(string value) => this.With(b => b.FirstName = value);

		private string LastName { get; set; } = "LastName";
		public PersonBuilder WithLastName(string value) => this.With(b => b.LastName = value);

		private PersonBuilder With(Action<PersonBuilder> assignment)
		{
			assignment(this);
			return this;
		}

		public Builder.Person Build()
		{
			var result = new Builder.Person(
				firstName: this.FirstName,
				lastName: this.LastName);
			return result;
		}
	}
}

Code and pdf at

https://ignatandrei.github.io/RSCG_Examples/v2/docs/Architect.DomainModeling

[ADCES]Azure OpenAI’s GPT-4V(ision) and DALL-E 3 & Testing at scale

Presentation 1: Vision Meets Fashion: Crafting Watch Aesthetics with Azure OpenAI’s GPT-4V(ision) and DALL-E 3
Description:
In this increasingly digitized era, the fusion of artificial intelligence and design is reshaping creative industries. This talk provides a practical exploration of this synergy, with a focus on enhancing watch designs (or just picking the “right” watch strap) using advanced AI technology.
Participants will be guided through a hands-on demonstration of analyzing a watch face with Azure OpenAI’s GPT-4 Vision, for identifying design attributes. Leveraging these insights, attendees will learn how to generate suitable strap ideas and designs that complement the watch’s aesthetics using the same AI.
The session will pivot towards actualizing these designs with DALL-E 3, demonstrating the model’s capability to render realistic images of watches with the new straps. Attendees will observe the Python code in action, gaining insights into how these powerful models can be controlled and utilized for design prototyping.
This session is designed for those interested in the practical application of AI in design, as well as developers and hobbyists eager to understand how to integrate such models into their Python projects. Attendees will gain firsthand experience in using state-of-the-art AI to bridge the gap between conceptualization and visualization in the design process, leaving the talk with actionable skills and knowledge.
Presenter : Vlad Iliescu, https://vladiliescu.net/

Presentation 2: Testing at scale – how to test when you go globally with a fleet of thousands of machines
Description: There are multiple types of tests we’d like to run – unit tests, end-to-end tests, manual tests, A/B tests. How should we organize them so they are fast and reliable?
What to do if we need to handle GDPR-protected data? How to run those tests when we have thousands of machines handling the traffic? How to rollback?
In this talk we’ll see how to build a real-life end-to-end testing pipeline used in biggest companies in the world. We’ll start with unit tests running locally in milliseconds, go through correctness tests, regression tests, performance tests, security tests, and finally end with A/B tests proving that our code is not only correct but also provides better experience for the customers. All of that based on experience with desktop, mobile, service, and machine learning domains at biggest companies.
Presenter : Adam Furmanek, https://blog.adamfurmanek.pl/

.NETC#

https://www.meetup.com/bucharest-a-d-c-e-s-meetup/events/297158675/

Aspire & Intro to GitHub Copilot

Azi , la 19:30

Prezentare 1: Aspire – running multiple services
Descriere: Utilizare Aspire pentru vizualizare multiple servicii, open telemetry, frontend , backend, containere
Prezentator: Andrei Ignat, http://msprogrammer.serviciipeweb.ro/

Prezentare 2: Intro to GitHub Copilot
Descriere : Voi prezenta:
– la ce am folosit eu Copilot
– ⁠ce e nou în Copilot Chat
– ⁠vom încerca să facem un joc de la zero – doar cu cod generat pe baza unei prezentări de la MS Build 2023 –
Prezentator : Julian (Iulian) Atanasoae , https://www.linkedin.com/in/julianatanasoae/

Va astept la https://meet.google.com/pmm-oeyc-dmy

[ADCES] .NET Core 8 What’s new

Details

Daniel Costea , https://www.linkedin.com/in/danielcostea/
What’s new in C# 12 and some AI / ML / news
Dan Patrascu Baba, https://www.linkedin.com/in/dan-patrascu-baba-08b78523/
What’s new in Blazor and the new ASPIRE app for distributed applications
Alexandru Badita,https://www.linkedin.com/in/alexandrubadita/
What’s new in .NET Core 8 Auth

Andrei Ignat , http://msprogrammer.serviciipeweb.ro/
What’s new in .NET 8 , ASP.NET Core , EF Core

I wait at  https://www.meetup.com/bucharest-a-d-c-e-s-meetup/events/295819291/

[ADCES] Redis & Microsoft Semantic Kernel

Azi , 14 noiembrie 2023, ora 19:30 ,  va fi un nou meetup ADCES despre

Redis & Microsoft Semantic Kernel

Presentation 1: Introduction to Redis
Description: Nice and gently introduction in Redis practice
Presenter: Marius Sorin Stratulat,https://www.linkedin.com/in/smariussorin

Presentation 2: Beyond Clicks: Unleashing the Power of Microsoft Semantic Kernel for a Semantic Interface in API Communication – A Deep Dive into the GPT-4 Powered Robot Car Demo
Description: Microsoft Semantic Kernel (SK) is a new technology that enables the integration of AI Large Language Models (LLMs) with conventional programming languages like C#, Python and Java. SK brings together several key components to provide planning and execution capabilities. These components include a robust kernel that provides the foundation for all other components, plugins (formerly known as skills) for performing specific tasks, connectors for interfacing with external systems, memories for storing information about past events, steps for defining individual actions, and pipelines for organizing complex multi-stage plans. We will explore how to build a semantic interface for an existing API (controlling a Car Robot) using plugins and execution plans containing semantic and native functions.
Presenter: Daniel Costea ,https://www.linkedin.com/in/danielcostea/

Va astept pe https://meet.google.com/dfq-ttsv-hoo
Multumesc
Andrei

Andrei Ignat weekly software news(mostly .NET)

* indicates required

Please select all the ways you would like to hear from me:

You can unsubscribe at any time by clicking the link in the footer of our emails. For information about our privacy practices, please visit our website.

We use Mailchimp as our marketing platform. By clicking below to subscribe, you acknowledge that your information will be transferred to Mailchimp for processing. Learn more about Mailchimp's privacy practices here.