Va invit la https://www.meetup.com/bucharest-a-d-c-e-s-meetup/events/303480535/?eventOrigin=group_upcoming_events
O sa vorbim despre analiza la prima vedere a solutiilor .NET si despre PowerBI.
Va astept la 19:30 la https://meet.google.com/mfo-cyfs-ztx
Timp de discutii / networking / profesional / neprofesional.
Va invitam pe toti
Tuesday, September 24, 2024
7:30 PM to 9:30 PM EEST
Add to calendar
<?XML:NAMESPACE PREFIX = “[default] http://www.w3.org/2000/svg” NS = “http://www.w3.org/2000/svg” />
Șoseaua Grozăvești 82 · București
How to find us
Quantic Pub. Telefon personal 0728200034
Prezentare 1: Introducere in Aspire, https://github.com/dotnet/aspire
Prezentator: Andrei Ignat, http://msprogrammer.serviciipeweb.ro/
Prezentare 2: La ce e bun Dapr si de ce ar trebui sa ma intereseze?
Prezentator: Alex Mang , https://www.linkedin.com/in/iamalexmang/
Va astept pe
https://meet.google.com/zqu-hcyh-vwe
Multumesc
Andrei
Asta seara, la ora 19:30, cu ADCES mergem impreuna la Quantic Pub , Șoseaua Grozăvești 82
Ne vedem acolo!
Presentation 1 : Generative AI for .NET Dev
Description: TBD
Presenter : Andrei Ignat, http://msprogrammer.serviciipeweb.ro/
Presentation 2 : Deep dive into open-source LLMs using Semantic Kernel and LLaVA
Description: LLaVA, the Large Language and Vision Assistant, is a multimodal model that combines vision and language understanding. It can reason over images, aiding in decision-making based on the environment, thereby enhancing autonomy.
Let’s see how we can combine this promising model with the power of an AI orchestrator like Microsoft Semantic Kernel.
Presenter : Daniel Costea, https://www.linkedin.com/in/danielcostea
https://www.meetup.com/bucharest-a-d-c-e-s-meetup/events/300509200/
In aceasta marti, la 19:30,avem 2 prezentari
Prezentare 1 : Raspberry Pico & Piano
Descriere : TBD
Prezentator : Adrian Cruceru, https://www.linkedin.com/in/adrian-cruceru-8123825/
Prezentare 2 : GraphQL: Building a Public API for a Cloud ERP and the Lessons We Learned
Descriere : TBD
Prezentator : Marius Bancila, https://mariusbancila.ro/blog/
Va astept la https://www.meetup.com/bucharest-a-d-c-e-s-meetup/events/300094296/
Timp de discutii / networking / profesional / neprofesional.
https://www.meetup.com/bucharest-a-d-c-e-s-meetup/events/298422520/
Va invitam pe toti
Șoseaua Grozăvești 82 · București
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
| 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
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/
https://www.meetup.com/bucharest-a-d-c-e-s-meetup/events/297158675/