The Logtalk Handbook
Contents
- User Manual
- Declarative object-oriented programming
- Main features
- Integration of logic and object-oriented programming
- Integration of event-driven and object-oriented programming
- Support for component-based programming
- Support for both prototype and class-based systems
- Support for multiple object hierarchies
- Separation between interface and implementation
- Private, protected and public inheritance
- Private, protected and public object predicates
- Parametric objects
- High level multi-threading programming support
- Smooth learning curve
- Compatibility with most Prolog systems and the ISO standard
- Performance
- Logtalk scope
- Nomenclature
- Messages
- Objects
- Protocols
- Categories
- Predicates
- Inheritance
- Event-driven programming
- Multi-threading programming
- Error handling
- Reflection
- Writing and running applications
- Starting Logtalk
- Running parallel Logtalk processes
- Source files
- Multi-pass compiler
- Compiling and loading your applications
- Compiler errors, warnings, and comments
- Loader files
- Libraries of source files
- Settings files
- Compiler linter
- Compiler flags
- Reloading source files
- Batch processing
- Optimizing performance
- Portable applications
- Conditional compilation
- Avoiding common errors
- Coding style guidelines
- Printing messages and asking questions
- Term and goal expansion
- Documenting
- Debugging
- Compiling source files in debug mode
- Procedure box model
- Defining spy points
- Tracing program execution
- Debugging using spy points
- Debugging commands
- Customizing term writing
- Context-switching calls
- Debugging messages
- Using the term-expansion mechanism for debugging
- Ports profiling
- Debug and trace events
- Performance
- Source code compilation modes
- Local predicate calls
- Calls to imported or inherited predicates
- Calls to module predicates
- Messages
- Automatic expansion of built-in meta-predicates
- Inlining
- Generated code simplification and optimizations
- Size of the generated code
- Debug mode overhead
- Other considerations
- Installing Logtalk
- Prolog integration and migration
- Reference Manual
- Grammar
- Control constructs
- Directives
- Built-in predicates
- Enumerating objects, categories and protocols
- Enumerating objects, categories and protocols properties
- Creating new objects, categories and protocols
- Abolishing objects, categories and protocols
- Objects, categories, and protocols relations
- Event handling
- Multi-threading
- Multi-threading engines
- Compiling and loading source files
- Flags
- Linter
- Built-in methods
- Tutorial
- FAQ
- General
- Compatibility
- Installation
- Portability
- Programming
- Should I use prototypes or classes in my application?
- Can I use both classes and prototypes in the same application?
- Can I mix classes and prototypes in the same hierarchy?
- Can I use a protocol or a category with both prototypes and classes?
- What support is provided in Logtalk for defining and using components?
- What support is provided in Logtalk for reflective programming?
- Troubleshooting
- Using compiler options on calls to the Logtalk compiling and loading predicates do not work!
- Gecko-based browsers (e.g. Firefox) show non-rendered HTML entities when browsing XML documenting files!
- Compiling a source file results in errors or warnings but the Logtalk compiler reports a successful compilation with zero errors and zero warnings!
- Usability
- Deployment
- Performance
- Is Logtalk implemented as a meta-interpreter?
- What kind of code Logtalk generates when compiling objects? Dynamic code? Static code?
- How about message-sending performance? Does Logtalk use static binding or dynamic binding?
- Which Prolog-dependent factors are most crucial for good Logtalk performance?
- How does Logtalk performance compare with plain Prolog and with Prolog modules?
- Licensing
- Support
- Developer Tools
- Overview
asdfassertionscode_metricsdead_code_scannerdebug_messagesdebuggerdiagramsdoclethelpissue_creatorlgtdoclgtunit- Main files
- API documentation
- Loading
- Testing
- Writing and running tests
- Automating running tests
- Parametric test objects
- Test dialects
- User-defined test dialects
- QuickCheck
- Skipping tests
- Checking test goal results
- Testing local predicates
- Testing non-deterministic predicates
- Testing generators
- Testing input/output predicates
- Suppressing tested predicates output
- Tests with timeout limits
- Setup and cleanup goals
- Test annotations
- Test execution times and memory usage
- Working with test data files
- Flaky tests
- Mocking
- Debugging messages in tests
- Debugging failed tests
- Code coverage
- Utility predicates
- Exporting test results in xUnit XML format
- Exporting test results in the TAP output format
- Generating Allure reports
- Exporting code coverage results in XML format
- Automatically creating bug reports at issue trackers
- Minimizing test results output
- Known issues
lintermakepacks- Requirements
- API documentation
- Loading
- Testing
- Usage
- Registries and packs storage
- Virtual environments
- Registry specification
- Registry handling
- Registry development
- Pack specification
- Pack URLs and Single Sign-On
- Multiple pack versions
- Pack dependencies
- Pack portability
- Pack development
- Pack handling
- Pack documentation
- Pinning registries and packs
- Testing packs
- Security considerations
- Best practices
- Installing Prolog packs
- Known issues
ports_profilerprofilertutorwrapper
- Libraries
- Overview
arbitraryassignvarsbase64basic_typescoroutiningcborcorecsvdatesdependentsdictionariesdifedcgeventsexpand_library_alias_pathsexpectedsformatgensymgenintgitgrammarsheapshierarchieshook_flowshook_objectshtmlidsintervalsjavajsonlistingloggingloopsmetameta_compilermutationsnested_dictionariesoptionalsoptionsosqueuesrandomreaderrecorded_databaseredissetsstatisticsterm_iotimeouttsvtypesunicode_dataulidunion_finduuidzippers
- Ports
- Contributions
- Glossary
- Bibliography
- Index