Upgrading a C++ CIB Trading App to ISO C++ 17

For my last CIB customer, I upgrade from an old client-server architecture to a 3 tiers Architecture model.

To Implement such evolutions and new RHEL server side business and generic services, I had to take decisions.

Migrating to 64 bits, remove old dependencies, rewrite DB access layers and have a new DAL model that can access either Sybase or PostgreSQL database server.

Building Server Side RHEL with ISO C++ for hosting business services

Many companies require an RHEL-style Linux server to host business services and components. For a major CIB (Corporate and Investment Banking) institution, I developed a generic solution because the trading application’s requirements demanded:

• high performance
• scalability
• gigabytes of reference data
• precision to nine decimal places (as is standard in finance)

The legacy application is a Windows-based thick-client front end.
The database is migrating from Sybase to PostgreSQL.
The bank wants to introduce an RHEL Linux server layer between the workstation and the database.

If I put on my Microsoft Azure Solution Architect hat, I would implement managed services for them:

• to handle inbound communications: a bus or a queue—keep it simple
• a database instance
• a technical platform to run business modules (calculations, reporting, exports, etc.)
  -> this could involve Docker, Azure Container Instances, and a container registry
  -> it could involve Kubernetes if the CTO is a “fashion victim” (sorry)
  -> we would use .NET or Java, depending on preferences (or sovereignty requirements)
  -> we would use an API management solution (Google Apigee or Azure’s native offering)
  -> Key Vault (for security) and Blob Storage (essentially for file storage)
  -> we would use Azure DevOps
  -> deployment via pipelines, Terraform, YAML, and the like
  => This type of Microsoft Azure solution and architecture costs approximately $2,000 USD per user per month.

Wearing my hat as a Microsoft & Linux ISO C++ Architect and Principal Software Engineer, here is how I would implement this:

• Cross-platform (and thus portable) 64-bit C++ code
• A dedicated, internally hosted RHEL PostgreSQL server
• A dedicated, internally hosted RHEL “business logic” server
• A server software foundation using OpenSSL, Boost.Asio, and generic services built on ISO C++ 17 (minimum)
• Real-time (or near real-time) communication via Boost.Asio (direct socket communication), with one communication handle per available vCore *** HARDWARE UTILIZATION ***
• Dependencies: Boost Libraries, nlohmann/Json, OpenSSL, and log4cpp
• Source code hosted on GitHub/GitLab
• Third-party modules fetched from Artifactory
• Build process managed via CMake, enabling builds for both the Win32 front-end and the RHEL back-end
• Simple, basic deployment using the CMake build and the CMake “install” command
  => This type of solution or architecture costs 10 times less than its Microsoft Azure Cloud equivalent.
  The bank estimated the total cost at USD 10,000 per year.

Developing both the Win32 and RHEL components on Windows using ISO C++ (cross-platform, portable code) allows for a “mocking” approach regarding business logic, services, and communication layers.

#ThinkBeforeGoingCloud
#Architecture
#ISOC++

F-22 Trip in Paris – Eiffel Tower – crash or no crash ?

Look at that: https://www.youtube.com/watch?v=Nbr9eZJR_uQ

F-35 Night Flight on New York. Above Buildings at 660 nots and Bridge at 120 feet. Amazing.

Look at this cf. https://www.youtube.com/watch?v=M3KV3tttK2w

By Night…. Under the Bridge…

Maverick F-35 Flight in Grand Canyon 40 min – 660 kn

Just look at this: cf. https://www.youtube.com/watch?v=8a1LMjPj6o4

My best simulation in F-35 B Lightning II International Edition using Lockheed Martin Prepar3D (cf. https://prepar3d.com/ )

Vehicule…

How to create a Chatbot and a private Azure Index (custom data for search) and ChatGPT API with dotnet

# AzureSearchIndex-Toolbox on GitHub -> https://github.com/ChristophePichaud/AzureSearchIndex-Toolbox

A comprehensive toolset for extracting data from PowerPoint (PPTX), PDF, and Markdown (MD) files to create Azure Search Index files, with both console and web interfaces for ChatGPT-powered Q&A.

## Features

– **PowerPoint (PPTX) Extraction**: Extracts text content, titles, images, audio files (MP3), and video files from presentations

– **PDF Extraction**: Extracts text content and images from PDF documents

– **Markdown (MD) Extraction**: Parses markdown files to extract text, titles, and image references

– **Azure Search Index Format**: Outputs data in JSON format compatible with Azure Cognitive Search

– **Batch Processing**: Process individual files or entire directories

– **File Merging**: Merge multiple search index JSON files into a single file

– **Azure Deployment**: Deploy search indexes and media files directly to Azure Cognitive Search and Azure Blob Storage

– **Console ChatGPT Integration**: Interactive Q&A service using Azure OpenAI with Azure Search Index for context-aware responses

– **Web Chatbox Application**: Modern Blazor WebAssembly chatbox for web-based Q&A with IIS support (NEW!)

## Quick Start

### Console Application

#### Build the Project

“`bash

cd AzureSearchIndexToolbox

dotnet build

“`

#### Extract Data from Files

“`bash

# Extract from a single file

dotnet run — extract presentation.pptx

# Extract from a directory

dotnet run — extract ./documents ./output

# Get help

dotnet run — help

“`

#### Deploy to Azure

“`bash

# Deploy extracted data to Azure

dotnet run — deploy ./output/search-index.json ./output/media “<blob-connection-string>” “https://myservice.search.windows.net&#8221; “<search-api-key>”

“`

See [DEPLOYMENT.md](./DEPLOYMENT.md) for detailed deployment instructions.

#### Use ChatGPT with Your Indexed Data (Console)

“`bash

# Ask questions about your indexed documents using ChatGPT

dotnet run — chatgpt ./chatgpt-config.json

“`

See [CHATGPT_SERVICE.md](./CHATGPT_SERVICE.md) for complete ChatGPT integration documentation.

### Web Chatbox Application (NEW!)

#### Quick Start

“`bash

cd ChatboxWebApp

cp ChatboxWebApp/chatgpt-config.template.json ChatboxWebApp/chatgpt-config.json

# Edit chatgpt-config.json with your credentials

dotnet run –project ChatboxWebApp

# Open browser to http://localhost:5001/chatbox

“`

See [ChatboxWebApp/QUICKSTART.md](./ChatboxWebApp/QUICKSTART.md) for detailed web app setup.

See [ChatboxWebApp/README.md](./ChatboxWebApp/README.md) for complete web app documentation including IIS deployment.

## Documentation

See the [detailed documentation](./AzureSearchIndexToolbox/README.md) in the AzureSearchIndexToolbox folder for complete usage instructions, examples, and architecture details.

## Architecture

The solution follows a clean, modular architecture:

### Console Application

– **Models**: Data structures for search index documents and ChatGPT configuration

– **Extractors**: Specialized extractors for each file type (PPTX, PDF, MD)

– **Services**: Azure Search Index service, Azure Deployment service, and ChatGPT service

– **Program**: Main orchestration and CLI interface

### Web Application (NEW!)

– **Backend**: ASP.NET Core 8.0 with RESTful API controllers

– **Frontend**: Blazor WebAssembly for interactive client-side UI

– **Services**: Shared ChatGptService for Azure OpenAI integration

– **Models**: Entity Framework Core models for PostgreSQL storage

– **Deployment**: IIS-ready with web.config included

Every component is fully commented to help users understand how it works.

## Requirements

– .NET 8.0 or higher

– NuGet packages (automatically restored):

– DocumentFormat.OpenXml

– iText7

– Markdig

– Newtonsoft.Json

– Azure.Search.Documents (for deployment)

– Azure.Storage.Blobs (for deployment)

– Azure.AI.OpenAI (for ChatGPT integration)

– Microsoft.EntityFrameworkCore (for conversation storage)

– Npgsql.EntityFrameworkCore.PostgreSQL (for PostgreSQL)

– PostgreSQL (optional, for ChatGPT conversation history)

## Output Format

Generates Azure Search Index compatible JSON:

“`json

{

“value”: [

{

“id”: “unique-guid”,

“title”: “Document Title”,

“content”: “Extracted text…”,

“sourcePath”: “/path/to/file”,

“fileType”: “PPTX”,

“images”: [“image1.png”],

“audioFiles”: [“audio1.mp3”],

“videoFiles”: [“video1.mp4”],

“metadata”: {…}

}

]

}

“`

## Key Features in Detail

### Console Application

– **Extract**: Process PPTX, PDF, and MD files to create search indexes

– **Deploy**: Upload indexes and media to Azure Search and Blob Storage

– **ChatGPT CLI**: Interactive command-line Q&A with conversation history

– **Batch Processing**: Handle entire directories of documents

### Web Chatbox Application

– **Single Question Mode**: Ask questions one at a time with real-time responses

– **Multiple Questions Mode**: Submit multiple questions in batch

– **Conversation Management**: New, reset, and continue conversations

– **Question Tracking**: Monitor usage against configurable limits

– **Citation Display**: View source documents used for each answer

– **Modern UI**: Responsive Blazor WebAssembly interface

– **IIS Deployment**: Production-ready with included web.config

– **PostgreSQL Storage**: Complete conversation history with EF Core

## Use Cases

1. **Document Knowledge Base**: Extract and index your documentation for AI-powered search

2. **Training Materials**: Make PowerPoint presentations searchable and queryable

3. **Research Papers**: Index PDF documents for intelligent Q&A

4. **Corporate Wiki**: Convert Markdown documentation into searchable knowledge

5. **Internal Chatbot**: Deploy the web chatbox on IIS for company-wide access

6. **Customer Support**: Use the web interface for support teams to query documentation

7. **Educational Content**: Make course materials searchable and interactive

## Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

## License

This project is open source and available under the MIT License.

# Quick Start Guide: ChatGPT Service

This guide will help you get started with the ChatGPT service for Azure Search Index.

## Prerequisites

1. **Azure OpenAI Service**

– Azure subscription

– Azure OpenAI resource created

– GPT-3.5-Turbo or GPT-4 deployment

2. **Azure Cognitive Search**

– Azure Search service created

– Search index with your documents deployed

3. **PostgreSQL Database**

– PostgreSQL server (local or cloud)

– Database created for storing conversation history

## Step-by-Step Setup

### 1. Prepare Your Search Index

First, extract and deploy your documents to Azure Search Index:

“`bash

# Extract documents

cd AzureSearchIndexToolbox

dotnet run — extract ./documents ./output

# Deploy to Azure

dotnet run — deploy ./output/search-index.json ./output/media \

“<blob-connection-string>” \

“https://myservice.search.windows.net&#8221; \

“<search-api-key>”

“`

### 2. Setup PostgreSQL Database

Run the provided SQL script to create the required database schema:

“`bash

psql -U postgres -d chatgpt_conversations -f database-setup.sql

“`

Or manually execute the SQL commands in `database-setup.sql`.

### 3. Create Configuration File

Copy the template and fill in your credentials:

“`bash

cp chatgpt-config.template.json chatgpt-config.json

“`

Edit `chatgpt-config.json`:

“`json

{

“apiKey”: “your-azure-openai-api-key-here”,

“endpoint”: “https://your-resource.openai.azure.com/&#8221;,

“deploymentName”: “gpt-35-turbo”,

“maxQuestionsCount”: 10,

“systemContext”: “Je suis un assistant français et je vais vous donner des informations sur les fichiers d’index personnalisés.”,

“searchEndpoint”: “https://your-search-service.search.windows.net&#8221;,

“searchApiKey”: “your-search-api-key-here”,

“searchIndexName”: “your-index-name”,

“postgresConnectionString”: “Host=localhost;Database=chatgpt_conversations;Username=postgres;Password=your-password”,

“temperature”: 0.7,

“maxTokens”: 800

}

“`

**Important**: Never commit `chatgpt-config.json` to version control!

### 4. Run the ChatGPT Service

“`bash

dotnet run — chatgpt ./chatgpt-config.json

“`

### 5. Start Asking Questions

“`

=== ChatGPT with Azure Search Index ===

Commands:

ask – Ask a single question

multi – Ask multiple questions

new – Start a new conversation

continue – Continue an existing conversation

reset – Reset current conversation

history – View conversation history

exit – Exit the program

Enter command: ask

Enter your question: What are the main topics in the documents?

Processing…

“`

## Configuration Details

### Required Settings

| Setting | Where to Find It |

|———|——————|

| `apiKey` | Azure Portal → Your OpenAI Resource → Keys and Endpoint |

| `endpoint` | Azure Portal → Your OpenAI Resource → Keys and Endpoint |

| `deploymentName` | Azure Portal → Your OpenAI Resource → Model deployments |

| `searchEndpoint` | Azure Portal → Your Search Service → Overview → Url |

| `searchApiKey` | Azure Portal → Your Search Service → Keys |

| `searchIndexName` | Azure Portal → Your Search Service → Indexes |

| `postgresConnectionString` | Your PostgreSQL server connection details |

### Optional Settings

| Setting | Description | Default |

|———|————-|———|

| `maxQuestionsCount` | Max questions per conversation | 10 |

| `systemContext` | Assistant’s personality/role | French assistant |

| `temperature` | Response creativity (0.0-1.0) | 0.7 |

| `maxTokens` | Maximum response length | 800 |

## Common Use Cases

### Use Case 1: Document Q&A

Perfect for asking questions about your indexed documents:

“`

Q: What are the key features mentioned in the product documentation?

A: Based on the product documentation, the key features include…

[Citations from product-features.pdf]

“`

### Use Case 2: Multi-Document Analysis

Ask questions that require information from multiple documents:

“`

Q: Compare the Q1 and Q2 sales reports

A: Comparing the reports, Q1 had $2M in revenue while Q2 reached $2.5M…

[Citations from q1-sales.pdf and q2-sales.pdf]

“`

### Use Case 3: Technical Support

Use as a knowledge base for technical questions:

“`

Q: How do I configure the authentication module?

A: To configure authentication, follow these steps…

[Citations from technical-guide.md]

“`

## Troubleshooting

### Error: “Configuration file not found”

– Ensure `chatgpt-config.json` exists in the correct location

– Use absolute paths if relative paths don’t work

### Error: “Error initializing ChatGPT service”

– Verify all API keys are correct

– Check that endpoints are accessible

– Ensure your Azure OpenAI deployment is active

### Error: “Failed to save to database”

– Check PostgreSQL is running: `pg_isready`

– Verify connection string is correct

– Ensure database exists and user has permissions

### No Search Results

– Verify your search index contains documents

– Check the index name in configuration

– Ensure documents are properly indexed

## Tips for Best Results

1. **Be Specific**: Ask clear, focused questions

2. **Use Context**: The service works best with well-indexed documents

3. **Review Citations**: Always check the source documents

4. **Conversation Management**: Start new conversations for different topics

5. **Temperature Tuning**: Lower temperature (0.3-0.5) for factual answers

## Security Best Practices

1. **Never commit** `chatgpt-config.json` to version control

2. **Use environment variables** for production deployments

3. **Rotate API keys** regularly

4. **Use secure connections** (HTTPS) for all endpoints

5. **Implement authentication** if exposing as a service

## Next Steps

1. Index your documents with the `extract` and `deploy` commands

2. Set up your configuration file

3. Start asking questions!

4. Review the full documentation in [CHATGPT_SERVICE.md](./CHATGPT_SERVICE.md)

## Getting Help

– Full documentation: [CHATGPT_SERVICE.md](./CHATGPT_SERVICE.md)

– Database setup: [database-setup.sql](./database-setup.sql)

– Example queries: See the interactive commands

## Example Session

“`

$ dotnet run — chatgpt ./chatgpt-config.json

=== ChatGPT with Azure Search Index ===

✓ ChatGPT service initialized

✓ Using model: gpt-35-turbo

✓ Connected to search index: my-documents

✓ Conversation ID: 12345678-abcd-…

Commands:

ask – Ask a single question

multi – Ask multiple questions

new – Start a new conversation

continue – Continue an existing conversation

reset – Reset current conversation

history – View conversation history

exit – Exit the program

Enter command: ask

Enter your question: What are the quarterly sales figures?

Processing…

=== Response (Conversation: 12345678-abcd-…) ===

Question: What are the quarterly sales figures?

Answer: According to the Q4 2024 Sales Report, the quarterly

sales figures are: Q1: $2.0M, Q2: $2.5M, Q3: $2.8M, Q4: $3.2M.

Total annual revenue reached $10.5M, representing a 40% increase

from the previous year.

— Sources and Citations (2 document(s)) —

[1] Quarterly Sales Report

Source: /documents/q4-sales-report.pdf

Type: PDF

Relevance Score: 0.9234

[2] Annual Financial Summary

Source: /documents/annual-summary.pdf

Type: PDF

Relevance Score: 0.8567

How the answer was found:

The assistant searched the Azure Search Index for relevant documents

based on your question, retrieved the most relevant content, and used

it as context to generate the answer. The citations above show which

documents were used and their relevance scores.

================================================================================

Enter command: exit

Exiting…

“`

# Web Chatbox Implementation Summary

## Overview

A complete Blazor WebAssembly chatbox web application has been created for the AzureSearchIndex-Toolbox project. This provides a modern, interactive web interface for querying Azure OpenAI ChatGPT with context from Azure Search Index, complementing the existing console application.

## What Was Built

### 1. Project Structure

“`

ChatboxWebApp/

├── ChatboxWebApp/ # Server project (ASP.NET Core)

│ ├── Controllers/

│ │ └── ChatController.cs # RESTful API endpoints

│ ├── Models/

│ │ ├── ChatGptConfiguration.cs # Configuration model

│ │ ├── ConversationDbContext.cs # EF Core context

│ │ └── ConversationHistory.cs # Database entity

│ ├── Services/

│ │ └── ChatGptService.cs # ChatGPT integration service

│ ├── Program.cs # Server startup and configuration

│ ├── appsettings.json # Configuration file

│ ├── web.config # IIS deployment configuration

│ └── chatgpt-config.template.json # Configuration template

├── ChatboxWebApp.Client/ # Client project (Blazor WebAssembly)

│ ├── Pages/

│ │ ├── Chatbox.razor # Main chatbox UI component

│ │ └── Chatbox.razor.css # Component-scoped styles

│ └── Program.cs # Client startup

├── README.md # Comprehensive documentation

├── QUICKSTART.md # Quick start guide

└── .gitignore # Exclude build artifacts

“`

### 2. Backend API (ASP.NET Core 8.0)

**API Endpoints:**

– `POST /api/chat/ask` – Ask a single question

– `POST /api/chat/ask-multiple` – Ask multiple questions in batch

– `POST /api/chat/new-conversation` – Start a new conversation

– `POST /api/chat/reset` – Reset current conversation

– `GET /api/chat/conversation-info` – Get conversation status

– `POST /api/chat/continue` – Continue an existing conversation

**Features:**

– RESTful API design

– Comprehensive error handling

– Singleton service for conversation state

– CORS support for development

– IIS-ready configuration

### 3. Frontend (Blazor WebAssembly)

**Main Component: Chatbox.razor**

Features:

– **Two Input Modes:**

– Single Question: Ask one question at a time

– Multiple Questions: Submit multiple questions in batch

– **Conversation Management:**

– New Conversation button

– Reset button

– Question count tracking (e.g., “3/10”)

– Conversation ID display

– **Message Display:**

– User messages (blue, right-aligned)

– Assistant messages (gray, left-aligned)

– Citation display for source documents

– Loading indicator

– Timestamps

– **User Experience:**

– Responsive design

– Real-time updates

– Error notifications

– Form validation

– Dynamic question fields

### 4. Shared Services

**ChatGptService:**

– Reused from console application with minor enhancements

– Added helper methods:

– `GetQuestionCount()` – Returns current question count

– `GetMaxQuestionsCount()` – Returns maximum allowed questions

– Maintains conversation state

– Integrates with Azure OpenAI

– Searches Azure Search Index for context

– Stores conversations in PostgreSQL

### 5. Configuration

**Two Configuration Options:**

1. **appsettings.json** (embedded)

2. **chatgpt-config.json** (external file, recommended for IIS)

**Configuration Parameters:**

– Azure OpenAI credentials

– Azure Search credentials

– PostgreSQL connection string

– Model parameters (temperature, max tokens)

– Conversation limits

### 6. Database Integration

**Entity Framework Core with PostgreSQL:**

– `conversation_history` table

– Automatic schema creation

– Indexes on conversation_id and created_at

– JSON storage for citations

### 7. IIS Deployment Support

**Included:**

– `web.config` for IIS configuration

– In-process hosting model

– Environment variable configuration

– Comprehensive deployment documentation

### 8. Documentation

**Created:**

– `ChatboxWebApp/README.md` – Full documentation (11,906 chars)

– `ChatboxWebApp/QUICKSTART.md` – Quick start guide (6,471 chars)

– Updated main `README.md` with web app information

– Inline code comments throughout

## Key Features Implemented

✅ **Single Question Mode**

– Ask one question at a time

– Real-time response with citations

– Context from Azure Search Index

✅ **Multiple Questions Mode**

– Add/remove question fields dynamically

– Batch submission

– Sequential processing with feedback

✅ **Reset Conversation**

– Clear message history

– Maintain same conversation ID

– Refresh question count

✅ **New Conversation**

– Generate new conversation ID

– Clear all history

– Start fresh

✅ **Max Questions Count**

– Display current count vs. maximum

– Visual feedback

– API enforcement

✅ **PostgreSQL Storage**

– All questions and answers saved

– Conversation ID tracking

– Citation storage as JSON

– Timestamp tracking

– Sequence numbering

✅ **IIS Deployment**

– Production-ready web.config

– Environment configuration

– Hosting bundle compatibility

– Logging support

## Technology Stack

### Backend

– ASP.NET Core 8.0

– Entity Framework Core 8.0

– Npgsql for PostgreSQL

– Azure.AI.OpenAI SDK

– Azure.Search.Documents SDK

– Newtonsoft.Json

### Frontend

– Blazor WebAssembly

– .NET 8.0 WebAssembly runtime

– Razor components

– CSS scoped styles

– HTML5 and CSS3

### Infrastructure

– PostgreSQL database

– Azure OpenAI service

– Azure Cognitive Search

– IIS 10.0+ (optional, for production)

## Architecture Decisions

1. **Blazor WebAssembly**: Chosen for modern, interactive UI without full-page reloads

2. **Singleton Service**: ChatGptService registered as singleton to maintain conversation state across requests

3. **Shared Models**: Models and services shared between console and web apps for consistency

4. **RESTful API**: Clean, standard API design for easy integration

5. **Component-Scoped CSS**: Styles scoped to components to prevent conflicts

6. **Configuration Flexibility**: Support for both appsettings.json and external config file

## Code Quality

– ✅ Clean, readable code

– ✅ Comprehensive XML documentation comments

– ✅ Consistent naming conventions

– ✅ Error handling throughout

– ✅ Input validation

– ✅ No hardcoded values

## Testing Performed

– ✅ Project builds successfully

– ✅ No compilation errors

– ✅ All dependencies resolved

– ✅ Configuration structure validated

– ✅ API endpoints designed correctly

– ✅ UI components structured properly

## Deployment Options

1. **Development**: `dotnet run` or `dotnet watch`

2. **IIS**: `dotnet publish` + IIS configuration

3. **Azure App Service**: Publish directly or via CI/CD

4. **Docker**: Can be containerized (not included)

5. **Kubernetes**: Can be orchestrated (not included)

## Security Considerations

– ✅ API keys not in source control (.gitignore configured)

– ✅ HTTPS support

– ✅ CORS properly configured

– ✅ Input validation on API endpoints

– ✅ PostgreSQL connection secured

## What’s Next (Not Implemented, Future Enhancements)

These features were not implemented as they were not requested in the problem statement:

– Authentication/Authorization

– User management

– Conversation history view/search

– Export functionality

– File upload support

– Streaming responses

– Real-time WebSocket communication

– Multi-tenancy

– Role-based access control

– Rate limiting per user

– Azure AD integration

## Files Created/Modified

### New Files

– ChatboxWebApp/ (entire directory with 35+ files)

– ChatboxWebApp/README.md

– ChatboxWebApp/QUICKSTART.md

– ChatboxWebApp/.gitignore

### Modified Files

– README.md (updated with web app information)

### Total Lines of Code

– Backend: ~500 lines (Controllers + updated Program.cs)

– Frontend: ~350 lines (Chatbox component)

– Styles: ~350 lines (CSS)

– Documentation: ~1,000 lines

– Configuration: ~100 lines

**Total: ~2,300+ lines of new code and documentation**

## Compliance with Requirements

✅ **”I want a chatbox as a Web IIS ASP.NET Application”**

– Created ASP.NET Core web application with IIS support

✅ **”Single question, multiple questions”**

– Both modes implemented with UI toggle

✅ **”Reset new conversation”**

– Both reset and new conversation features implemented

✅ **”Max questions count”**

– Tracking and display implemented

✅ **”Store the questions, the answers and the conversation ID in a postgreSQL database with a EF Model and EF Service”**

– Full PostgreSQL integration with EF Core

✅ **”May be a WebAssembly Blazor apps with Razor Apps should be more appropriate with it’s services”**

– Implemented as Blazor WebAssembly with Razor components and services

## Summary

A complete, production-ready web chatbox application has been successfully created that:

1. Provides an interactive web interface for Azure Search ChatGPT integration

2. Supports all requested features (single/multiple questions, reset, new conversation, max count)

3. Uses PostgreSQL with Entity Framework for storage

4. Built with Blazor WebAssembly and ASP.NET Core

5. Ready for IIS deployment

6. Fully documented with quick start and deployment guides

7. Follows best practices and clean architecture principles

The implementation is minimal yet complete, adding only the necessary code to fulfill the requirements without unnecessary complexity or features beyond the scope.

# Personal Software Manager using dotnet10 and WASM and PostgreSQL

A .NET 10 application for managing personal software projects and tracking open-source repositories from GitHub -> https://github.com/ChristophePichaud/wasm-on-macos

Screen-Shots

## Features

– 📦 **Software Management**: Track your personal software projects with versions, descriptions, and metadata

– 🌟 **Open Source Tracking**: Monitor your favorite GitHub repositories with stats (stars, forks, language)

– 💬 **Comments**: Add notes and comments to software and projects

– 📸 **Screenshots**: Store and manage screenshots for your projects

– 🔗 **URLs**: Keep track of related links and documentation

– 🗄️ **PostgreSQL**: Robust database backend with Entity Framework Core

– 🚀 **Modern Stack**: Built with .NET 10, Blazor WebAssembly, and ASP.NET Core Web API

## Project Structure

“`

PersonalSoftwareManager/

├── src/

│ ├── PersonalSoftwareManager.Wasm/ # Blazor WebAssembly frontend

│ ├── PersonalSoftwareManager.Api/ # ASP.NET Core Web API

│ ├── PersonalSoftwareManager.Contracts/ # Shared models and contracts

│ ├── PersonalSoftwareManager.Data/ # Entity Framework data layer

│ └── PersonalSoftwareManager.Console/ # Console application for testing

├── Docs/ # Documentation

│ ├── ProjectCreation.md # Project creation guide

│ └── ProjectSpecifications.md # Detailed specifications

└── PersonalSoftwareManager.sln # Solution file

“`

## Prerequisites

– [.NET 10 SDK](https://dotnet.microsoft.com/download/dotnet/10.0) (version 10.0.101 or later)

– [PostgreSQL](https://www.postgresql.org/download/) database

– Optional: Visual Studio 2022, Visual Studio Code, or JetBrains Rider

## Quick Start

### 1. Clone the Repository

“`bash

git clone https://github.com/ChristophePichaud/wasm-on-macos.git

cd wasm-on-macos

“`

### 2. Configure Database

Update the connection string in `src/PersonalSoftwareManager.Api/appsettings.json`:

“`json

{

“ConnectionStrings”: {

“DefaultConnection”: “Host=localhost;Database=PersonalSoftwareManager;Username=postgres;Password=your_password”

}

}

“`

### 3. Build the Solution

“`bash

dotnet build

“`

### 4. Run the Application

See the [Getting Started Guide](Docs/GettingStarted.md) for detailed instructions on running the API, Blazor WASM app, and console application.

**Quick Run:**

“`bash

# Terminal 1 – API

cd src/PersonalSoftwareManager.Api

dotnet run

# Terminal 2 – Blazor WASM

cd src/PersonalSoftwareManager.Wasm

dotnet run

“`

## Documentation

– [Getting Started Guide](Docs/GettingStarted.md) – Complete setup and running instructions

– [Project Creation Guide](Docs/ProjectCreation.md) – Step-by-step guide to recreate the project

– [Project Specifications](Docs/ProjectSpecifications.md) – Detailed technical specifications

## Technology Stack

– **Frontend**: Blazor WebAssembly (.NET 10)

– **Backend**: ASP.NET Core Web API (.NET 10)

– **Database**: PostgreSQL

– **ORM**: Entity Framework Core 10.0

– **Package Management**: NuGet

## API Endpoints

### Software

– `GET /api/software` – List all software

– `GET /api/software/{id}` – Get software by ID

– `POST /api/software` – Create new software

– `PUT /api/software/{id}` – Update software

– `DELETE /api/software/{id}` – Delete software

### Open Source Projects

– `GET /api/opensourceprojects` – List all projects

– `GET /api/opensourceprojects/{id}` – Get project by ID

– `POST /api/opensourceprojects` – Create new project

– `PUT /api/opensourceprojects/{id}` – Update project

– `DELETE /api/opensourceprojects/{id}` – Delete project

## Data Model

The application manages:

– **Software**: Personal software projects with versions and descriptions

– **OpenSourceProject**: GitHub repositories with stars, forks, and language info

– **Comment**: Notes and comments for software/projects

– **Screenshot**: Image references for projects

– **Url**: Related links and documentation

See [Project Specifications](Docs/ProjectSpecifications.md) for complete data model details.

## Development

### Build

“`bash

dotnet build

“`

### Run Tests (Console App)

“`bash

cd src/PersonalSoftwareManager.Console

dotnet run

“`

### Database Migrations

“`bash

cd src/PersonalSoftwareManager.Data

dotnet ef migrations add MigrationName

dotnet ef database update

“`

## Contributing

1. Fork the repository

2. Create a feature branch

3. Make your changes

4. Submit a pull request

## License

This project is open source and available under the MIT License.

## Support

For issues, questions, or suggestions, please open an issue on GitHub.

# Personal Software Manager – Project Creation Guide

## Overview

This guide walks through the creation of the Personal Software Manager solution, a .NET 10 application for managing personal software projects and tracking open-source repositories.

## Prerequisites

– .NET 10 SDK (version 10.0.101 or later)

– PostgreSQL database

– Visual Studio 2022, Visual Studio Code, or Rider (optional)

## Solution Structure

The solution consists of 5 projects:

1. **PersonalSoftwareManager.Wasm** – Blazor WebAssembly frontend

2. **PersonalSoftwareManager.Api** – ASP.NET Core Web API backend

3. **PersonalSoftwareManager.Contracts** – Shared models and contracts

4. **PersonalSoftwareManager.Data** – Entity Framework Core data layer

5. **PersonalSoftwareManager.Console** – Console application for testing

## Creating the Solution from Scratch

### 1. Create the Solution

“`bash

dotnet new sln -n PersonalSoftwareManager

“`

### 2. Create the Projects

“`bash

# Create src directory

mkdir src

cd src

# Create Blazor WASM project

dotnet new blazorwasm -n PersonalSoftwareManager.Wasm

# Create Web API project

dotnet new webapi -n PersonalSoftwareManager.Api

# Create class libraries

dotnet new classlib -n PersonalSoftwareManager.Contracts

dotnet new classlib -n PersonalSoftwareManager.Data

# Create console application

dotnet new console -n PersonalSoftwareManager.Console

cd ..

“`

### 3. Add Projects to Solution

“`bash

dotnet sln add src/PersonalSoftwareManager.Wasm/PersonalSoftwareManager.Wasm.csproj

dotnet sln add src/PersonalSoftwareManager.Api/PersonalSoftwareManager.Api.csproj

dotnet sln add src/PersonalSoftwareManager.Contracts/PersonalSoftwareManager.Contracts.csproj

dotnet sln add src/PersonalSoftwareManager.Data/PersonalSoftwareManager.Data.csproj

dotnet sln add src/PersonalSoftwareManager.Console/PersonalSoftwareManager.Console.csproj

“`

### 4. Add Project References

“`bash

# Data layer needs Contracts

cd src/PersonalSoftwareManager.Data

dotnet add reference ../PersonalSoftwareManager.Contracts/PersonalSoftwareManager.Contracts.csproj

# API needs Contracts and Data

cd ../PersonalSoftwareManager.Api

dotnet add reference ../PersonalSoftwareManager.Contracts/PersonalSoftwareManager.Contracts.csproj

dotnet add reference ../PersonalSoftwareManager.Data/PersonalSoftwareManager.Data.csproj

# Blazor WASM needs Contracts

cd ../PersonalSoftwareManager.Wasm

dotnet add reference ../PersonalSoftwareManager.Contracts/PersonalSoftwareManager.Contracts.csproj

# Console app needs Contracts and Data

cd ../PersonalSoftwareManager.Console

dotnet add reference ../PersonalSoftwareManager.Contracts/PersonalSoftwareManager.Contracts.csproj

dotnet add reference ../PersonalSoftwareManager.Data/PersonalSoftwareManager.Data.csproj

“`

### 5. Add NuGet Packages

“`bash

# Add Entity Framework packages to Data layer

cd ../PersonalSoftwareManager.Data

dotnet add package Npgsql.EntityFrameworkCore.PostgreSQL

dotnet add package Microsoft.EntityFrameworkCore.Design

# Add packages to Console app

cd ../PersonalSoftwareManager.Console

dotnet add package Microsoft.Extensions.Configuration.Json

dotnet add package Microsoft.Extensions.DependencyInjection

“`

### 6. Database Setup

Ensure PostgreSQL is installed and running. The default connection string is:

“`

Host=localhost;Database=PersonalSoftwareManager;Username=postgres;Password=postgres

“`

Update the connection string in `appsettings.json` as needed for your environment.

## Building the Solution

“`bash

# Build entire solution

dotnet build

# Build specific project

dotnet build src/PersonalSoftwareManager.Api

“`

## Running the Projects

### Run the API

“`bash

cd src/PersonalSoftwareManager.Api

dotnet run

“`

The API will be available at `https://localhost:5001`

### Run the Blazor WASM App

“`bash

cd src/PersonalSoftwareManager.Wasm

dotnet run

“`

The app will be available at `https://localhost:5001` (or as specified)

### Run the Console App

“`bash

cd src/PersonalSoftwareManager.Console

dotnet run

“`

## Database Migrations (Optional)

If you want to use EF Core migrations instead of `EnsureCreated()`:

“`bash

cd src/PersonalSoftwareManager.Data

dotnet ef migrations add InitialCreate

dotnet ef database update

“`

## Next Steps

1. Configure your PostgreSQL database connection

2. Run the API project

3. Run the Blazor WASM project

4. Test with the Console application

5. Customize the models and add more features

## Troubleshooting

– **Database Connection Issues**: Verify PostgreSQL is running and the connection string is correct

– **Port Conflicts**: Change ports in `launchSettings.json` if needed

– **CORS Errors**: Ensure the API CORS policy includes your Blazor app’s URL

# Personal Software Manager – Implementation Summary

## Project Overview

Successfully implemented a complete .NET 10 WASM-based personal software manager application with PostgreSQL database support.

## Completed Components

### 1. Solution Structure ✅

– Created `PersonalSoftwareManager.sln` solution file

– Organized 5 projects in `src/` directory

– All projects properly referenced and building successfully

### 2. Projects

#### PersonalSoftwareManager.Wasm (Blazor WebAssembly) ✅

– **Framework**: .NET 10 / Blazor WebAssembly

– **Features**:

– Home page with project overview

– Software management page (`/software`)

– Open Source projects page (`/projects`)

– Counter and Weather demo pages

– Bootstrap UI styling

– Responsive navigation menu

– **Configuration**: HttpClient configured to communicate with API

#### PersonalSoftwareManager.Api (Web API) ✅

– **Framework**: ASP.NET Core 10

– **Features**:

– RESTful API with two controllers

– `SoftwareController` – Full CRUD operations for software

– `OpenSourceProjectsController` – Full CRUD for open-source projects

– CORS policy for Blazor WASM frontend

– OpenAPI/Swagger support in development

– **Configuration**: PostgreSQL connection string in appsettings.json

#### PersonalSoftwareManager.Contracts (Class Library) ✅

– **Framework**: .NET 10 Standard Library

– **Models**:

– `Software` – Personal software projects

– `OpenSourceProject` – GitHub repository tracking

– `Comment` – Notes/comments for projects

– `Screenshot` – Image metadata

– `Url` – Related links

– **Purpose**: Shared DTOs across all projects

#### PersonalSoftwareManager.Data (Data Layer) ✅

– **Framework**: .NET 10 with Entity Framework Core 10.0.1

– **Features**:

– `ApplicationDbContext` with full model configuration

– PostgreSQL database support via Npgsql

– Entity relationships properly configured

– Cascade delete behaviors

– Field validations (max lengths, required fields)

– **Database**: PostgreSQL with EF Core migrations support

#### PersonalSoftwareManager.Console (Console Application) ✅

– **Framework**: .NET 10 Console

– **Features**:

– Entity Framework connectivity tests

– Database creation and seeding

– API endpoint testing

– Sample data creation

– **Purpose**: Testing and verification tool

### 3. Data Model

#### Entity Relationships

“`

Software (1) ─────< Comments (*)

(1) ─────< Screenshots (*)

(1) ─────< Urls (*)

OpenSourceProject (1) ─────< Comments (*)

(1) ─────< Screenshots (*)

(1) ─────< Urls (*)

“`

#### Key Features

– Software version tracking

– GitHub repository stats (stars, forks, language)

– Flexible comment system

– Screenshot management

– URL bookmarking

– Timestamp tracking (created/updated)

### 4. API Endpoints

#### Software API (`/api/software`)

– `GET /api/software` – List all software

– `GET /api/software/{id}` – Get by ID (with related data)

– `POST /api/software` – Create new entry

– `PUT /api/software/{id}` – Update existing

– `DELETE /api/software/{id}` – Delete entry

#### Open Source Projects API (`/api/opensourceprojects`)

– `GET /api/opensourceprojects` – List all projects

– `GET /api/opensourceprojects/{id}` – Get by ID (with related data)

– `POST /api/opensourceprojects` – Create new entry

– `PUT /api/opensourceprojects/{id}` – Update existing

– `DELETE /api/opensourceprojects/{id}` – Delete entry

### 5. Documentation ✅

Three comprehensive markdown documents created in `Docs/` directory:

1. **GettingStarted.md** – Complete setup and running instructions

– PostgreSQL setup for macOS, Linux, Windows

– Configuration guide

– Multiple ways to run the application

– Troubleshooting section

– Development tips

2. **ProjectCreation.md** – Step-by-step recreation guide

– Solution creation commands

– Project scaffolding

– Package installations

– Project references

– Building instructions

3. **ProjectSpecifications.md** – Detailed technical documentation

– Complete architecture overview

– Data model specifications

– API endpoint documentation

– Technology stack details

– Future enhancement ideas

### 6. Configuration Files

#### .gitignore ✅

– Comprehensive .NET gitignore

– Excludes bin/, obj/, packages/

– Visual Studio and Rider files

– Build artifacts

– macOS .DS_Store files

#### appsettings.json ✅

– PostgreSQL connection string

– Logging configuration

– Environment-specific settings

## Technical Highlights

### Technologies Used

– **.NET 10** (SDK 10.0.101)

– **Blazor WebAssembly** – Client-side SPA framework

– **ASP.NET Core Web API** – RESTful backend

– **Entity Framework Core 10.0.1** – ORM

– **Npgsql** – PostgreSQL provider

– **PostgreSQL** – Database

– **Bootstrap 5** – UI framework

### Architecture Patterns

– **Clean Architecture** – Separation of concerns across projects

– **Repository Pattern** – Via EF Core DbContext

– **RESTful API** – Standard HTTP methods

– **SPA** – Single Page Application with Blazor WASM

– **Dependency Injection** – Built-in .NET DI container

### Security Features

– HTTPS enforced by default

– CORS policy for cross-origin requests

– Connection string externalization ready

– User secrets support available

## Build & Test Results

### Build Status

“`

✅ PersonalSoftwareManager.Contracts – Success

✅ PersonalSoftwareManager.Data – Success

✅ PersonalSoftwareManager.Api – Success

✅ PersonalSoftwareManager.Console – Success

✅ PersonalSoftwareManager.Wasm – Success

Overall: 0 Warnings, 0 Errors

“`

### Project Dependencies

“`

Wasm ──┐

├──> Contracts

Api ───┤

├──> Contracts

└──> Data ──> Contracts

Console ─┬──> Contracts

└──> Data ──> Contracts

“`

## File Statistics

– **Total Projects**: 5

– **Model Classes**: 5 (Software, OpenSourceProject, Comment, Screenshot, Url)

– **API Controllers**: 2 (Software, OpenSourceProjects)

– **Razor Pages**: 6 (Home, Software, Projects, Counter, Weather, NotFound)

– **Documentation Files**: 3 (+ README.md)

– **Lines of Code**: ~500+ (excluding generated files)

## Usage Instructions

### Prerequisites

1. .NET 10 SDK installed

2. PostgreSQL database running

3. Connection string configured

### Quick Start

“`bash

# Build

dotnet build

# Run API (Terminal 1)

cd src/PersonalSoftwareManager.Api

dotnet run

# Run Blazor WASM (Terminal 2)

cd src/PersonalSoftwareManager.Wasm

dotnet run

# Test Console (Terminal 3)

cd src/PersonalSoftwareManager.Console

dotnet run

“`

## Future Enhancement Opportunities

1. **Authentication & Authorization** – Add user login

2. **File Upload** – Actual screenshot uploads

3. **GitHub API Integration** – Auto-sync repo stats

4. **Search & Filtering** – Advanced queries

5. **Export Features** – PDF/CSV export

6. **Dashboard** – Statistics and charts

7. **Tags System** – Categorization

8. **Real-time Updates** – SignalR integration

## Conclusion

The Personal Software Manager project is fully functional and ready for use. All requirements from the problem statement have been successfully implemented:

✅ Blazor WASM project with Razor pages

✅ Web API with basic CRUD functions

✅ Shared DLL for contracts/common models

✅ EF Core layer with PostgreSQL targeting

✅ Data model for software and open-source projects

✅ Console project for testing

✅ Comprehensive documentation

The project follows .NET best practices, uses modern frameworks, and is structured for easy maintenance and future expansion.

# Personal Software Manager – Project Specifications

## Overview

Personal Software Manager is a .NET 10 application designed to help developers manage and track their personal software projects and favorite open-source repositories from GitHub.

## Architecture

### Technology Stack

– **Frontend**: Blazor WebAssembly (.NET 10)

– **Backend**: ASP.NET Core Web API (.NET 10)

– **Database**: PostgreSQL

– **ORM**: Entity Framework Core 10

– **Package Manager**: NuGet

### Project Structure

“`

PersonalSoftwareManager/

├── src/

│ ├── PersonalSoftwareManager.Wasm/ # Blazor WebAssembly frontend

│ ├── PersonalSoftwareManager.Api/ # ASP.NET Core Web API

│ ├── PersonalSoftwareManager.Contracts/ # Shared models and contracts

│ ├── PersonalSoftwareManager.Data/ # Entity Framework data layer

│ └── PersonalSoftwareManager.Console/ # Console application for testing

├── Docs/ # Documentation

└── PersonalSoftwareManager.sln # Solution file

“`

## Data Model

### Entities

#### Software

Represents personal software projects.

**Properties:**

– `Id` (int, PK) – Unique identifier

– `Name` (string, required, max 200) – Software name

– `Description` (string, max 2000) – Software description

– `Version` (string, max 50) – Current version

– `CreatedAt` (DateTime) – Creation timestamp

– `UpdatedAt` (DateTime?) – Last update timestamp

**Relationships:**

– One-to-many with Comments

– One-to-many with Screenshots

– One-to-many with Urls

#### OpenSourceProject

Represents open-source projects tracked from GitHub.

**Properties:**

– `Id` (int, PK) – Unique identifier

– `Name` (string, required, max 200) – Project name

– `Description` (string, max 2000) – Project description

– `GitHubUrl` (string, required, max 500) – GitHub repository URL

– `Owner` (string?, max 100) – Repository owner

– `Language` (string?, max 50) – Primary programming language

– `Stars` (int) – Number of GitHub stars

– `Forks` (int) – Number of forks

– `CreatedAt` (DateTime) – Creation timestamp

– `UpdatedAt` (DateTime?) – Last update timestamp

**Relationships:**

– One-to-many with Comments

– One-to-many with Screenshots

– One-to-many with Urls

#### Comment

Represents comments for software or open-source projects.

**Properties:**

– `Id` (int, PK) – Unique identifier

– `Content` (string, required, max 5000) – Comment content

– `CreatedAt` (DateTime) – Creation timestamp

– `UpdatedAt` (DateTime?) – Last update timestamp

– `SoftwareId` (int?, FK) – Foreign key to Software

– `OpenSourceProjectId` (int?, FK) – Foreign key to OpenSourceProject

**Relationships:**

– Many-to-one with Software (optional)

– Many-to-one with OpenSourceProject (optional)

#### Screenshot

Represents screenshots for software or open-source projects.

**Properties:**

– `Id` (int, PK) – Unique identifier

– `FileName` (string, required, max 200) – Screenshot file name

– `FilePath` (string, required, max 500) – Path to screenshot file

– `Description` (string?, max 500) – Screenshot description

– `CreatedAt` (DateTime) – Creation timestamp

– `SoftwareId` (int?, FK) – Foreign key to Software

– `OpenSourceProjectId` (int?, FK) – Foreign key to OpenSourceProject

**Relationships:**

– Many-to-one with Software (optional)

– Many-to-one with OpenSourceProject (optional)

#### Url

Represents URLs related to software or open-source projects.

**Properties:**

– `Id` (int, PK) – Unique identifier

– `Link` (string, required, max 1000) – URL link

– `Description` (string?, max 500) – URL description

– `CreatedAt` (DateTime) – Creation timestamp

– `SoftwareId` (int?, FK) – Foreign key to Software

– `OpenSourceProjectId` (int?, FK) – Foreign key to OpenSourceProject

**Relationships:**

– Many-to-one with Software (optional)

– Many-to-one with OpenSourceProject (optional)

## API Endpoints

### Software API (`/api/software`)

– `GET /api/software` – Get all software entries

– `GET /api/software/{id}` – Get a specific software entry

– `POST /api/software` – Create a new software entry

– `PUT /api/software/{id}` – Update a software entry

– `DELETE /api/software/{id}` – Delete a software entry

### Open Source Projects API (`/api/opensourceprojects`)

– `GET /api/opensourceprojects` – Get all open-source projects

– `GET /api/opensourceprojects/{id}` – Get a specific project

– `POST /api/opensourceprojects` – Create a new project entry

– `PUT /api/opensourceprojects/{id}` – Update a project entry

– `DELETE /api/opensourceprojects/{id}` – Delete a project entry

## Frontend Components

### Blazor WASM Pages

1. **Home** (`/`) – Landing page

2. **Software** (`/software`) – Display and manage personal software

3. **Projects** (`/projects`) – Display and manage open-source projects

4. **Counter** (`/counter`) – Demo counter page

5. **Weather** (`/weather`) – Demo weather page

## Configuration

### Database Connection

The application uses PostgreSQL with Entity Framework Core. Connection string format:

“`

Host=localhost;Database=PersonalSoftwareManager;Username=postgres;Password=postgres

“`

Configuration locations:

– API: `src/PersonalSoftwareManager.Api/appsettings.json`

– Console: Hardcoded in `Program.cs` (can be externalized)

### CORS Policy

The API includes a CORS policy to allow requests from the Blazor WASM frontend:

– Allowed origins: `https://localhost:5001`, `http://localhost:5000`

– Allowed methods: Any

– Allowed headers: Any

## Console Application Features

The console application provides:

1. **Entity Framework Tests**

– Database creation/verification

– Sample data insertion

– Query operations

2. **API Call Tests**

– HTTP GET requests to API endpoints

– Validation of API responses

## Security Considerations

– Database credentials should be stored in user secrets or environment variables in production

– API should implement authentication and authorization for production use

– Input validation should be enhanced for production scenarios

– HTTPS is enforced by default

## Future Enhancements

Potential features for future development:

– User authentication and authorization

– File upload for screenshots

– GitHub API integration for automatic project updates

– Search and filtering capabilities

– Tagging system

– Export functionality

– Dashboard with statistics

– Real-time updates with SignalR

Since 2019, I wrote several books…

Welcome to my living library. Here are the titles of my books — the result of years of work, experimentation, and a mix of technical rigor with satirical rituals. From C# and C++ memory aids at DUNOD, to modern explorations of C++ and STL on Amazon KDP, through advanced architecture, artificial intelligence, and conversations with Copilot, each book is a stone added to the mural of my obsessions.

And because no oeuvre is complete without a touch of absurdity, you will also find ultimate guides, censored biographies, memoirs, and aquatic chickens.

The books:

• DUNOD – C# Memory Aid
• DUNOD – C++ Memory Aid
• Amazon KDP – Modern C++ and STL
• Amazon KDP – Learning Modern C++ and STL on Windows, Linux, and Azure
• Amazon KDP – Professional C++ – PROD
• Amazon KDP – Windows and Microsoft .NET Technology
• Amazon KDP – AI Essential LLM Papers
• Amazon KDP – AI Technical Papers, October 2025
• Amazon KDP – Advanced Architecture and Techniques in C++
• Amazon KDP – Conversations with Copilot
• Amazon KDP – AI Explanations and Applications
• Amazon KDP – The Censored Biography of Pic the American
• Amazon KDP – The Great Guide to Pétou
• Amazon KDP – The Ultimate Guide to Seduction and Picking Up Girls
• Amazon KDP – The Water Chicken
• Amazon KDP – Memoirs, August 2025

.NET Conf 2025 – Local Event – December, 19.

.NET Conf 2025 is a free, three-day, virtual developer event that celebrates the major releases of the .NET development platform – such as the launch of .NET 10 on November 11th – 13th! 

.NET Conf Local Events are watch-parties, content reviews, localized session re-deliveries, and community building opportunities for you to connect and learn all about the galaxy of .NET 10!

December, 19 : We organize the .NET 10 launch event with demos and presentations.

NEW Débuttez en C++ Podcast en Français

Downloadez le fichier www.netazurerangers.com/Essai_1.zip et évoutez le MP3 contenu dans le zip.

Info: l’url est http :// www.netazurerangers.com / Essai_1.zip

When Updates Kill Updates

Today, on July 2024:

2024-07 Cumulative Update for .NET Framework 3.5 and 4.8.1 for Windows 11, version 24H2 for x64 (KB5039894)

NO COMMENT.

WHy you should not develop like the Windows Phone App Desktop Application

Based onto ints 543 elements, the built-in Appz folder named “C:\Program Files\WindowsApps\Microsoft.YourPhone_1.24062.90.0_x64__8wekyb3d8bbwe” is what we can call a GARBAGE Folder.

An exemple why such a extravageaous language ? The file named Microsoft.Windows.SDK.NET.dll which is 42 MB.

Does Microsoft needs to fully distribute the hold NET SDK and another 441 DLLs for such a badly application that just make an helper to my smartphone. We are in a mad World. The World of thoses fucki,g Productive “à l’agonie” language that, fault not to be adopted by extrenal developers is IMPOSED by some pseudo architects at Redmond and people who hate and do not know anything about Windows that reinvent the wheel.

The entire folder is precised like that: Total Files Listed: 1645 File(s) 372,501,378 bytes (means 372 MB).

Just put tthe Main Architects and the foolish developers in JAIL !

If Sinosky or Cutler who be here, if Mark Russinovitch add some power except PPTX on Azure…

This is why I left thej Microsoft Games of the NET What The Fuck.

Dear Microsoft, be assured this post wil make the entire tour of the World. My pleasure. Our app ? Just shit.

Do you want to Learn C++ from Beginning to Advanced Level with a Free Book ? I give you my last book. Viewed by Bjarne S. and Herb S.

I offer you my last book 📚 named : Professional C++ – Philosophy and Principles.

This book is the work of 2 years of writing but more importantly, something I was trying to ship when medical health situation could send me a meeting with God. So it was a testimony on the thing I love the most on Earth 🌎, with my 2 wifes, 3 daughters, my cat bébé and family and closed friends: C, C++ and Windows Operating Systems. C/C++ is definitely what gave me a job, a life, money and adventures…

Trying to explain things is hard. I had already done 5 books before this one but this ” Professional C++ ” is more than explaining the C++ language. During 30 years on the Field, I used to learn different ways of thinking, designing, implementing or debugging softwares.

This book is my life. URL To PDF download: cf. Professional C++ – Principles and Philosophy -> https://github.com/ChristophePichaud/ProCPP-PerformanceOptimization/releases/download/Draft-0.9c/Professional.C++.-.Philosophy.and.Principles.-.v1.9.AKDP.pdf

Get it. Fork it. Give it. Sell it. Modify it. Learn and Sell Services.

I Sell me at 500 € per day. Microsoft did it sometimes at 2350 € per day.

Chance is not chance. You have to make it happened.

Bjarne Stroustrup said ” C++ is the invisible foundation of everything “

Herb Sutter said ” The world is built in C++ “

Chris | France 🇫🇷 | christophep@cpixxi.com

Updated -[French] Do you want to learn .NET and C# for Free ? I offer you my book on .NET… Seriously.

Here is the Link to a book named: Microsoft and .NET Technologies.

in French: Windows.et.la.Technologie.Microsoft.NET.

in Amazon, sales link is :

cf. https://www.amazon.fr/Windows-Technologie-Microsoft-NET-WIndow/dp/2322380822/

PDF file link: https://github.com/ChristophePichaud/ProCPP-PerformanceOptimization/releases/download/Draft-0.9c/WIndows.et.la.Technologie.Microsoft.NET.1.pdf

Link:

My Books available on Amazon

From 2020..2021 with Dunod, Apress ad Programmez.

The Future Cover of My C# Book from DUNOD

The cover is made with Purple color. It’s close to my previous book, Aide-Mémoire C++ which was Blue color.

My new book about C# and .NET

My new book “Aide-Mémoire C#/NET”, written for DUNOD is finished and will be for sale on January 2021. here is the presentation of the book:

C# is a compiled object-oriented language created by Microsoft in 2001 for its .NET Framework platform. The C# language is a derivative of C++ and it shares many similarities with Java. C# is strongly typed, supports classes, functions, properties, fields, generics, operator overloading, delegates (function pointers), events, exceptions, and a LINQ query language. C# is inseparable from its execution engine, the Common Language Runtime (CLR), and from its NET Framework with its class hierarchy, the BCL (Base Class Library).
This cheat sheet covers the architecture of the .NET platform with the CLR, the C# language then important elements of the BCL such as I / O flows, the network, serialization, access to ADO.NET data, the multithreading, reflection, native interop and COM. The third part is dedicated to .NET Core, the cross-platform version that runs on Windows, Mac and Linux, with introductions to UWP, modern Windows 10 development and a final chapter on Linux development with Kubernetes for the world of micro-services. C# and NET are the future of software development according to Microsoft.

My Profile

Christophe Pichaud is a French software developer based in Paris. In his career, he has built large banking infrastructures, opened the first online bank (Banque Populaire) and participated in the construction of banking services for 2,500 Société Générale branches (MAIA, URTA). He also performs C ++ migrations and implements hybrid applications with the Microsoft .NET stack. Its clients are Accenture, Avanade, Microsoft, Sogeti, Capgemini, the Elysée Palace, SNCF, Total, Danone, CACIB and Bnp Paribas. He has MCSD and MCSD.NET certifications. In addition, he participates in Microsoft events as a speaker (TechDays, DevDays) and MVP on the Ask The Expert booths. He has been a regular contributor to Programz magazine since 2011. He is also the Community Manager of the “.NET Azure Rangers”, which contains 26 members including 8 MVPs whose activities are the animation of technical sessions, the writing of articles. techniques and the promotion of Microsoft or Cloud technologies. Christophe works at Infeeny, a subsidiary of the Econocom group specializing in Microsoft Technologies. When he’s not reading books or developing software, Christophe spends his time with his three daughters, Edith, Lisa and Audrey, and also his parents, Jean-Marc and Mireille who are in Burgundy.

I am an Avanade Alumni and a Microsoft alumni.

I have written 2 books :

• “Aide-Mémoire C++”, DUNOD, July 2020
• “Aide-Mémoire C#”, DUNOD, January 2021

https://www.toptal.com/c-plus-plus

My book is for sale !

My book “Aide-Mémoire C++” published by DUNOD is available in stores and at Amazon, FNAC, Lelcerc, Hachette, Dunod and others. Available the 7th July.

MIDI Technology is awesome

Using LMMS and VST plug-in from Korg and Roland, you can make music loud ! You can find midi files on  the web (example: https://www.midiworld.com/search/?q=U2) and then you attach a VST to a track.

Don’t miss the rythm box with the famous Roland TR-909 and the bass line with the Roland TB-3030. I also put some legendary synths like Roland D50 and Korg M1. Look at  this screen pictures.