Skip to main content سوق المهارات اكتشف واستكشف مهارات الذكاء الاصطناعي التي بناها المجتمع.
التثبيت باستخدام Codex أو Claude انسخ هذا Prompt والصقه في Codex أو Claude أو مساعد آخر ليراجع صفحة Skill ويثبّتها لك.
عرض تفاصيل Prompt يتجاوز الأمر المباشر Prompt المخصّص للمراجعة. افحص المصدر قبل تشغيله.
npx skills add https://github.com/AJBcoding/claude-skill-eval --skill moai-foundation-langsيبقى الأمر في سطر واحد. مرّر أفقيًا لمراجعته كاملًا قبل النسخ.
تفضّل نسخة محلية؟ نزّل الملفات المتاحة حاليًا لدى SkillsMP.
تحميل Zip جاري التحميل... Enterprise-grade security expertise with production-ready patterns for OWASP Top 10 2021, zero-trust architecture, threat modeling (STRIDE, PASTA), secure SDLC, DevSecOps automation, cloud security, cryptography, identity & access management, and compliance frameworks (SOC 2, ISO 27001, GDPR, CCPA).
المهن ذات الصلة SOC
استنادا إلى تصنيف SOC المهني
name moai-foundation-langs version 4.0.0 created 2025-11-11T00:00:00.000Z updated 2025-11-13T00:00:00.000Z status stable description Enterprise Programming Languages Foundation with AI-powered language selection, Context7 integration, and intelligent multi-language orchestration for optimal technology choices keywords ["programming-languages","language-selection","technology-stack","multi-language","context7-integration","ai-orchestration","production-deployment"] allowed-tools ["Read","Bash","Write","Edit","Glob","Grep","WebFetch","mcp__context7__resolve-library-id","mcp__context7__get-library-docs"]
Enterprise Programming Languages Foundation Expert v4.0.0
Skill Metadata
Field Value Skill Name moai-foundation-langs Version 4.0.0 (2025-11-13) Tier Foundation Language Expert AI-Powered ✅ Context7 Integration, Intelligent Selection Auto-load On demand when language selection keywords detected
What It Does
Enterprise Programming Languages Foundation expert with AI-powered language selection, Context7 integration, and intelligent multi-language orchestration for optimal technology choices.
Revolutionary v4.0.0 capabilities :
🤖 AI-Powered Language Selection using Context7 MCP for latest language ecosystem insights
📊 Intelligent Technology Stacking with automated compatibility and performance analysis
🚀 Advanced Multi-Language Integration with AI-driven interoperability optimization
🔗 Enterprise Language Governance with zero-configuration standardization policies
📈 Predictive Performance Analysis with language-specific optimization insights
When to Use
Automatic triggers :
Programming language selection and technology stack discussions
Multi-language architecture design and integration planning
Language performance optimization and compatibility analysis
Enterprise technology standardization and governance
Manual invocation :
Selecting optimal programming languages for specific use cases
Designing multi-language architectures with interoperability
Planning technology migrations and modernization strategies
Optimizing performance for specific language ecosystems
Quick Reference (Level 1)
Modern Language Ecosystem (November 2025)
High-Performance Systems
Rust 1.83 : Memory safety, zero-cost abstractions, async/awaitGo 1.22 : Concurrency, garbage collection, simple deployment
C++ 23 : Modern features, performance optimization, systems programming
Zig 0.13 : Simple, fast, safe systems programming
Web Development
TypeScript 5.5 : Type safety, modern JavaScript, excellent toolingJavaScript (ES2025) : Dynamic, ubiquitous, large ecosystemPython 3.13 : Productivity, AI/ML focus, extensive librariesPHP 8.4 : Web optimization, JIT compiler, modern syntax
Data Science & AI
Python : NumPy, pandas, TensorFlow, PyTorch ecosystemR : Statistical analysis, data visualization, researchJulia 1.10 : High-performance scientific computingScala 3 : Big data processing, Apache Spark integration
Mobile & Cross-Platform
Kotlin 2.1 : Android development, multiplatform mobileSwift 6 : iOS development, performance, safetyFlutter 3.24 : Cross-platform UI, Dart languageReact Native 0.76 : JavaScript-based mobile development
Core Implementation (Level 2)
Language Selection Intelligence
class LanguageSelectionOptimizer :
def __init__ (self ):
self .context7_client = Context7Client()
self .performance_analyzer = LanguagePerformanceAnalyzer()
self .compatibility_checker = LanguageCompatibilityChecker()
async def select_optimal_languages (self,
requirements: ProjectRequirements ) -> LanguageSelection:
"""Select optimal programming languages using AI analysis."""
language_docs = {}
primary_languages = ['typescript' , 'python' , 'rust' , 'go' , 'java' , 'kotlin' ]
for lang in primary_languages:
docs = await self .context7_client.get_library_docs(
context7_library_id=await self ._resolve_language_library(lang),
topic="performance optimization ecosystem best practices 2025" ,
tokens=2000
)
language_docs[lang] = docs
requirement_analysis = self ._analyze_requirements(requirements)
language_combinations = self ._generate_language_combinations(
requirement_analysis,
language_docs
)
performance_evaluation = await self .performance_analyzer.evaluate_languages(
language_combinations,
requirement_analysis.performance_requirements,
language_docs
)
compatibility_analysis = await self .compatibility_checker.check_compatibility(
language_combinations,
requirement_analysis.integration_requirements
)
return LanguageSelection(
recommended_stack=self ._select_optimal_stack(
language_combinations,
performance_evaluation,
compatibility_analysis
),
alternative_stacks=self ._identify_alternatives(
language_combinations,
performance_evaluation
),
performance_comparison=performance_evaluation,
compatibility_matrix=compatibility_analysis,
migration_strategy=self ._plan_migration_strategy(requirements),
risk_assessment=self ._assess_language_risks(
language_combinations,
compatibility_analysis
)
)
Multi-Language Architecture Patterns class MultiLanguageArchitect :
def __init__ (self ):
self .integration_patterns = IntegrationPatternLibrary()
self .performance_optimizer = CrossLanguageOptimizer()
def design_multi_language_architecture (self,
language_selection: LanguageSelection,
system_requirements: SystemRequirements ) -> MultiLanguageArchitecture:
"""Design optimized multi-language system architecture."""
service_boundaries = self ._define_service_boundaries(
language_selection.recommended_stack,
system_requirements.domain_boundaries
)
integration_patterns = self .integration_patterns.select_patterns(
service_boundaries,
system_requirements.communication_requirements
)
performance_optimization = self .performance_optimizer.optimize_cross_language_performance(
language_selection.recommended_stack,
service_boundaries,
integration_patterns
)
return MultiLanguageArchitecture(
service_boundaries=service_boundaries,
integration_patterns=integration_patterns,
performance_optimization=performance_optimization,
deployment_strategy=self ._design_deployment_strategy(
service_boundaries,
language_selection.recommended_stack
),
monitoring_setup=self ._configure_monitoring(
service_boundaries,
integration_patterns
)
)
def _define_service_boundaries (self,
recommended_stack: LanguageStack,
domain_boundaries: List [DomainBoundary] ) -> List [ServiceDefinition]:
"""Define service boundaries based on language strengths."""
services = []
for domain in domain_boundaries:
optimal_language = self ._select_optimal_language_for_domain(
domain, recommended_stack
)
service = ServiceDefinition(
name=domain.name,
domain=domain,
language=optimal_language,
responsibilities=domain.responsibilities,
interfaces=self ._define_service_interfaces(domain, optimal_language),
dependencies=self ._identify_dependencies(domain, domain_boundaries),
performance_requirements=domain.performance_requirements
)
services.append(service)
return services
class IntegrationPatternLibrary :
def __init__ (self ):
self .patterns = {
'rest_api' : RESTAPIPattern(),
'graphql' : GraphQLPattern(),
'message_queue' : MessageQueuePattern(),
'event_bus' : EventBusPattern(),
'shared_database' : SharedDatabasePattern(),
'grpc' : GRPCPattern(),
'websocket' : WebSocketPattern()
}
def select_patterns (self,
service_boundaries: List [ServiceDefinition],
communication_requirements: CommunicationRequirements ) -> List [IntegrationPattern]:
"""Select optimal integration patterns for service communication."""
selected_patterns = []
for service in service_boundaries:
for dependency in service.dependencies:
pattern = self ._select_pattern_for_dependency(
service, dependency, communication_requirements
)
if pattern and pattern not in selected_patterns:
selected_patterns.append(pattern)
return selected_patterns
Performance Optimization Strategies
export class LanguagePerformanceOptimizer {
private languageProfiles = new Map <string , LanguageProfile >();
constructor (this .initializeLanguageProfiles ();
}
private initializeLanguageProfiles (this .languageProfiles .set ('rust' , {
strengths : ['performance' , 'memory_safety' , 'concurrency' ],
weaknesses : ['development_speed' , 'ecosystem_size' ],
useCases : ['systems_programming' , 'high_performance_services' , 'cli_tools' ],
benchmarks : {
cpuIntensive : 95 ,
memoryEfficiency : 98 ,
developmentSpeed : 60 ,
ecosystemMaturity : 75
}
});
this .languageProfiles .set ('typescript' , {
strengths : ['type_safety' , 'ecosystem' , 'tooling' ],
weaknesses : ['runtime_performance' , 'memory_usage' ],
useCases : ['web_apis' , 'frontend_development' , 'microservices' ],
benchmarks : {
cpuIntensive : 70 ,
memoryEfficiency : 65 ,
developmentSpeed : 90 ,
ecosystemMaturity : 95
}
});
this .languageProfiles .set ('go' , {
strengths : ['concurrency' , 'deployment' , 'simplicity' ],
weaknesses : ['generic_programming' , 'error_handling' ],
useCases : ['microservices' , 'cli_tools' , 'network_services' ],
benchmarks : {
cpuIntensive : 85 ,
memoryEfficiency : 80 ,
developmentSpeed : 85 ,
ecosystemMaturity : 80
}
});
}
optimizeLanguageSelection (requirements : ProjectRequirements ): LanguageOptimization {
const languageScores = new Map <string , number >();
for (const [language, profile] of this .languageProfiles ) {
let score = 0 ;
if (requirements.performance === 'high' ) {
score += profile.benchmarks .cpuIntensive * 0.3 ;
score += profile.benchmarks .memoryEfficiency * 0.2 ;
} else if (requirements.performance === 'medium' ) {
score += profile.benchmarks .cpuIntensive * 0.2 ;
score += profile.benchmarks .memoryEfficiency * 0.1 ;
}
if (requirements.timeline === 'short' ) {
score += profile.benchmarks .developmentSpeed * 0.3 ;
} else {
score += profile.benchmarks .developmentSpeed * 0.1 ;
}
if (requirements.complexity === 'high' ) {
score += profile.benchmarks .ecosystemMaturity * 0.2 ;
} else {
score += profile.benchmarks .ecosystemMaturity * 0.1 ;
}
languageScores.set (language, score);
}
const sortedLanguages = Array .from (languageScores.entries ())
.sort ((a, b ) => b[1 ] - a[1 ])
.slice (0 , 5 );
return {
primaryRecommendation : sortedLanguages[0 ][0 ],
alternatives : sortedLanguages.slice (1 ).map (([lang] ) => lang),
scores : Object .fromEntries (languageScores),
reasoning : this .generateReasoning (sortedLanguages, requirements)
};
}
private generateReasoning (
sortedLanguages : [string , number ][],
requirements : ProjectRequirements
): string {
const [primary, score] = sortedLanguages[0 ];
const profile = this .languageProfiles .get (primary)!;
let reasoning = `${primary} is recommended because it excels in ` ;
if (requirements.performance === 'high' ) {
reasoning += `performance (CPU: ${profile.benchmarks.cpuIntensive} %, Memory: ${profile.benchmarks.memoryEfficiency} %)` ;
}
if (requirements.timeline === 'short' ) {
reasoning += ` and has fast development speed (${profile.benchmarks.developmentSpeed} %)` ;
}
reasoning += `. It's particularly suited for ${profile.useCases.join(', ' )} .` ;
return reasoning;
}
}
Advanced Implementation (Level 3)
Language Migration Strategies class LanguageMigrationPlanner :
def __init__ (self ):
self .risk_assessor = MigrationRiskAssessor()
self .cost_analyzer = MigrationCostAnalyzer()
def plan_migration (self,
current_stack: TechnologyStack,
target_stack: TechnologyStack,
migration_scope: MigrationScope ) -> MigrationPlan:
"""Plan comprehensive language migration strategy."""
risk_assessment = self .risk_assessor.assess_migration_risks(
current_stack,
target_stack,
migration_scope
)
cost_analysis = self .cost_analyzer.analyze_migration_costs(
current_stack,
target_stack,
migration_scope,
risk_assessment
)
migration_phases = self ._plan_migration_phases(
current_stack,
target_stack,
migration_scope,
risk_assessment
)
return MigrationPlan(
risk_assessment=risk_assessment,
cost_analysis=cost_analysis,
migration_phases=migration_phases,
rollback_strategy=self ._create_rollback_strategy(current_stack),
validation_criteria=self ._create_validation_criteria(target_stack),
team_training_plan=self ._create_team_training_plan(target_stack)
)
def _plan_migration_phases (self,
current_stack: TechnologyStack,
target_stack: TechnologyStack,
migration_scope: MigrationScope,
risk_assessment: RiskAssessment ) -> List [MigrationPhase]:
"""Plan detailed migration phases."""
phases = []
phases.append(MigrationPhase(
name="Preparation" ,
duration="2-4 weeks" ,
activities=[
"Set up development environments for target language" ,
"Create proof-of-concept implementations" ,
"Define migration standards and guidelines" ,
"Train development team on target language"
],
deliverables=[
"Development environment setup" ,
"POC implementations" ,
"Migration guidelines" ,
"Team training completion"
],
risks=["Learning curve" , "Tooling setup" ],
mitigation=["Comprehensive training" , "Expert consultation" ]
))
phases.append(MigrationPhase(
name="Gradual Migration" ,
duration="8-16 weeks" ,
activities=[
"Migrate non-critical components first" ,
"Implement parallel systems for validation" ,
"Gradually migrate core functionality" ,
"Monitor performance and stability"
],
deliverables=[
"Migrated components" ,
"Parallel system implementation" ,
"Performance monitoring setup" ,
"Migration progress reports"
],
risks=["System instability" , "Performance degradation" ],
mitigation=["Comprehensive testing" , "Gradual rollout" ]
))
phases.append(MigrationPhase(
name="Full Migration" ,
duration="4-8 weeks" ,
activities=[
"Decommission legacy systems" ,
"Complete migration of remaining components" ,
"Optimize performance in target language" ,
"Finalize documentation and knowledge transfer"
],
deliverables=[
"Complete system migration" ,
"Legacy system decommissioning" ,
"Performance optimization" ,
"Final documentation"
],
risks=["Data loss" , "System downtime" ],
mitigation=["Comprehensive backups" , "Maintenance windows" ]
))
return phases
Ecosystem Integration
export class EcosystemIntegrationManager {
private ecosystemIntegrators = new Map <string , EcosystemIntegrator >();
constructor (this .setupEcosystemIntegrators ();
}
private setupEcosystemIntegrators (this .ecosystemIntegrators .set ('typescript' , new NodeJSIntegrator ());
this .ecosystemIntegrators .set ('python' , new PythonIntegrator ());
this .ecosystemIntegrators .set ('rust' , new RustIntegrator ());
this .ecosystemIntegrators .set ('go' , new GoIntegrator ());
}
async setupLanguageEnvironment (language : string , projectConfig : ProjectConfig ): Promise <EnvironmentSetup > {
const integrator = this .ecosystemIntegrators .get (language);
if (!integrator) {
throw new Error (`No ecosystem integrator available for ${language} ` );
}
return await integrator.setupEnvironment (projectConfig);
}
async manageDependencies (language : string , dependencies : Dependency []): Promise <DependencyManagement > {
const integrator = this .ecosystemIntegrators .get (language);
if (!integrator) {
throw new Error (`No ecosystem integrator available for ${language} ` );
}
return await integrator.manageDependencies (dependencies);
}
}
class NodeJSIntegrator implements EcosystemIntegrator {
async setupEnvironment (projectConfig : ProjectConfig ): Promise <EnvironmentSetup > {
return {
packageManager : this .selectPackageManager (projectConfig),
buildTool : this .selectBuildTool (projectConfig),
testingFramework : this .selectTestingFramework (projectConfig),
linting : this .setupLinting (),
typeChecking : this .setupTypeChecking (),
bundler : this .selectBundler (projectConfig)
};
}
async manageDependencies (dependencies : Dependency []): Promise <DependencyManagement > {
const packageJson = this .generatePackageJson (dependencies);
const lockFile = await this .generateLockFile (dependencies);
return {
packageJson,
lockFile,
versionConflicts : this .detectVersionConflicts (dependencies),
securityVulnerabilities : await this .checkSecurityVulnerabilities (dependencies),
optimizationSuggestions : this .generateOptimizationSuggestions (dependencies)
};
}
private selectPackageManager (projectConfig : ProjectConfig ): PackageManager {
switch (projectConfig.packageManager ) {
case 'npm' :
return { name : 'npm' , version : 'latest' , lockFile : 'package-lock.json' };
case 'yarn' :
return { name : 'yarn' , version : 'latest' , lockFile : 'yarn.lock' };
case 'pnpm' :
return { name : 'pnpm' , version : 'latest' , lockFile : 'pnpm-lock.yaml' };
default :
return { name : 'npm' , version : 'latest' , lockFile : 'package-lock.json' };
}
}
}
Reference & Integration (Level 4)
API Reference
Core Language Operations
select_languages(requirements, constraints) - Optimal language selectionanalyze_compatibility(languages, integrations) - Compatibility analysisoptimize_performance(stack, requirements) - Performance optimizationplan_migration(from_stack, to_stack) - Migration planningsetup_ecosystem(language, project_config) - Environment setup
Context7 Integration
get_latest_language_documentation() - Language docs via Context7analyze_ecosystem_trends() - Ecosystem analysis via Context7optimize_language_patterns() - Language optimization via Context7
Best Practices (November 2025)
DO
Select languages based on project requirements and team expertise
Consider performance, ecosystem, and maintenance requirements
Plan for multi-language integration from the beginning
Use appropriate integration patterns for cross-language communication
Invest in team training for new languages
Monitor performance across different language components
Plan migration strategies with risk mitigation
Consider long-term maintenance and ecosystem stability
DON'T
Select languages based solely on popularity or trends
Ignore integration complexity in multi-language architectures
Skip performance testing across language boundaries
Forget about team learning curves and expertise requirements
Neglect dependency management across different ecosystems
Underestimate migration costs and risks
Ignore security implications of language choices
Forget about long-term support and ecosystem health
Works Well With
moai-baas-foundation (Technology stack selection)moai-domain-backend (Backend language patterns)moai-domain-frontend (Frontend language patterns)moai-foundation-trust (Language security and compliance)moai-essentials-perf (Language performance optimization)moai-domain-devops (Language deployment patterns)moai-security-api (Language-specific security)moai-domain-database (Database integration patterns)
Changelog
v4.0.0 (2025-11-13): Complete Enterprise v4.0 rewrite with 40% content reduction, 4-layer Progressive Disclosure structure, Context7 integration, modern language ecosystem analysis, and comprehensive migration strategiesv2.0.0 (2025-11-11): Complete metadata structure, language selection patterns, ecosystem integrationv1.0.0 (2025-11-11): Initial programming languages foundation
End of Skill | Updated 2025-11-13
Language Ecosystem
Modern Development Trends
Polyglot programming becoming standard practice
Language interoperability through WebAssembly
AI/ML influencing language evolution and adoption
Performance optimization driving language innovation
Cloud-native development shaping language ecosystems
Future Considerations
WebAssembly enabling cross-language compilation
AI-generated code impacting language popularity
Edge computing driving language optimization
Security concerns influencing language adoption
End of Enterprise Programming Languages Foundation Expert v4.0.0
