Look at that: https://www.youtube.com/watch?v=Nbr9eZJR_uQ
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…
Mistral IA Job Application submitted!
Trying…. Trying…
I have made 3 books about IA:
- AI : Explications and Applications: Une évasion intellectuelle pour un ami
- IA : Les Publications Techniques Essentielles – Partie I: Le Best-Of de la Recherche Scientifique
- AI Technical Papers – October 2025: From collection of my friend Ralphy…
Here are the books cover.
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” “<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” \
“<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/”,
“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”,
“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/
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
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.
C++ Code and Assembly traduction in Release
Do you know why C++ is the best ? Because it can be high level and very focus on optimized asm code generation. Here a sample of code:
#include "pch.h"
class Param
{
};
template<typename T>
class Factory
{
public:
static shared_ptr<T> CreateObject(const Param& param)
{
shared_ptr<T> pObj = nullptr;
pObj = make_shared<T>();
_pLastElement = pObj;
return pObj;
}
static shared_ptr<T> GetLastCreatedObject()
{
return _pLastElement;
}
private:
static shared_ptr<T> _pLastElement;
};
template<typename T>
shared_ptr<T> Factory<T>::_pLastElement = nullptr;
class Employee
{
};
class Product
{
};
template<typename T>
class Vector
{
public:
Vector(int size)
{
_size = size;
_data = new T[_size];
}
~Vector()
{
delete[] _data;
}
T GetData(int index)
{
return _data[index];
}
void SetData(int index, T value)
{
_data[index] = value;
}
private:
T* _data;
int _size = 0;
};
int main()
{
Vector<int> v1(10);
v1.SetData(2, 20);
int value = v1.GetData(2);
cout << value << endl; //20
Vector<string> v2(1000);
v2.SetData(10, "string 10");
v2.SetData(100, "string 100");
string value2 = v2.GetData(10);
cout << value2 << endl; // string 10
Vector<Product> v3(200000);
Param param;
shared_ptr<Employee> p1 = Factory<Employee>::CreateObject(param);
if (p1 != nullptr)
{
cout << "OK" << endl; //OK
}
shared_ptr<Employee> p2 = Factory<Employee>::CreateObject(param);
shared_ptr<Employee> p3 = Factory<Employee>::CreateObject(param);
shared_ptr<Employee> pLast = Factory<Employee>::GetLastCreatedObject();
if (pLast == p3)
{
cout << "OK ptr" << endl;
}
}
The result is an associated asm code generated : here
There is approximatively 1000 lines of asm for 100 lines of C++ with templates and shared_ptr. It’s amazing !
C++ rocks.
ChristopheP on Microsoft Technologies 