We source, vet, and manage hiring so you can meet qualified candidates in days, not months. Strong English, U.S. time zone overlap, and compliant hiring built in.
.svg){kind=logo}
Self is a purely object-oriented, prototype-based programming language developed at Stanford in the 1980s. Unlike class-based languages (Java, Python, C++), Self uses prototypes as the fundamental unit of code reuse. Every object is a clone of an existing object, modified as needed. This approach directly influenced JavaScript's prototype inheritance model.
Self pioneered key concepts in object-oriented design: direct manipulation of objects through an integrated development environment, reflective capabilities for introspection and modification, and slots (methods and data combined as properties). The language was designed around the principle that everything is an object and that programmers should be able to inspect and modify any object at runtime.
Self is rarely used in production systems today, making it a specialized niche. Companies using Self typically maintain legacy systems built in the 1990s or are researching advanced meta-programming concepts. The language is valuable primarily in academic contexts and for engineers studying the history and theory of object-oriented programming.
The influence of Self is broader than its current adoption. JavaScript's prototype-based model directly borrowed from Self. Lua's table-based design shares similar flexibility. Understanding Self deeply provides insight into meta-programming approaches that appear in more contemporary languages like Ruby, Python, and JavaScript.
Self hiring is rare in practice. Only maintain or extend legacy Self systems if you have existing code written in Self. Building new systems in Self is impractical due to the tiny ecosystem and near-zero adoption in industry.
If you have a historical Self codebase that needs maintenance or feature development, hire a Self specialist. These engineers are typically architects or senior researchers who understand both the language deeply and the theoretical foundations of object-oriented programming.
Self expertise is valuable in educational and research contexts. Universities teaching advanced programming language concepts may hire Self specialists to teach or research prototype-based systems. Research projects exploring meta-programming or reflective systems may benefit from Self knowledge.
Avoid using Self for new projects. If you need prototype-based object-oriented design, use JavaScript (Prototype mode) or Lua. If you need meta-programming capabilities, use Python, Ruby, or JavaScript. Self is a historical artifact valuable for learning, not for building production systems.
Look for deep understanding of meta-programming, object-oriented theory, and the specific design of Self's object model. A good Self hire should be able to explain how slots work, how Self implements method dispatch, how the development environment enables live object manipulation, and how Self influenced JavaScript.
Essential skills include: deep knowledge of Self's class and slot definitions, understanding of the reflective capabilities, familiarity with the Self development environment, and knowledge of prototype-based inheritance at a theoretical level.
Red flags include: engineers who've read about Self but never used it, those who confuse Self with JavaScript prototypes, and candidates unable to articulate why prototype-based design is different from class-based design.
Mid-level (3-5 years): Writes solid Self code, understands the development environment, can diagnose and fix issues, understands the theoretical foundations of prototype-based OOP.
Senior (5+ years): Deep expertise in Self's design and implementation. Can architect complex systems using meta-programming capabilities. Understands how Self influenced other languages. Can mentor and explain subtle aspects of the language.
Tell me about the last Self system you worked on. What was it for and what was your role? Look for concrete examples and depth of engagement. If they've truly worked with Self, they should have real project experience to discuss.
How do you approach learning about a language or technology with very limited resources or community? This is relevant for Self work. Strong answers show resourcefulness, ability to read source code, and comfort learning through experimentation.
Explain what you understand about prototype-based inheritance and how it differs from class-based inheritance. This tests theoretical understanding. They should articulate why prototypes are different, the implications for code reuse, and how Self implements it.
What do you see as the lasting influence of Self on modern programming? Tests depth of knowledge. Strong answers mention JavaScript prototypes, meta-programming capabilities, and design principles that influenced other languages.
Describe a time you used Self's reflective capabilities to solve a problem. Look for evidence of understanding Self's unique features and how they enable capabilities other languages struggle with.
Explain how Self's object model works. What are slots, how does method dispatch work, and how does it compare to classes? This is fundamental. Look for understanding of how objects contain both methods and data, how slots work, how Self handles inheritance through delegation to prototype objects.
Write a simple Self program that demonstrates prototype-based inheritance and object creation. Look for understanding of how to clone objects, modify slots, and demonstrate that inheritance happens through object relationships, not class definitions.
How would you introspect an object in Self to discover what methods it responds to? Tests knowledge of Self's reflective capabilities. Look for understanding of the development environment and how to inspect runtime object structure.
Compare how polymorphism works in Self versus a class-based language like Java. What are the implications? Tests theoretical understanding of object-oriented design and how different inheritance models affect polymorphic behavior.
Describe how you would implement a meta-programming pattern (like dynamic method creation) in Self. Tests practical understanding of Self's reflective and dynamic capabilities. Look for explanation of how to modify objects at runtime.
Challenge: Design and implement a Self system that demonstrates prototype-based object reuse. Create objects that inherit from prototypes and show how modifying a prototype affects cloned objects. Explain your design choices.
Scoring Rubric: Demonstrates understanding of prototype-based inheritance, shows how cloning and modification work in Self, code is clear and follows Self patterns, explains how this model compares to class-based approaches.
Specialized Market Rates:
Self experts are extremely rare in Latin America. If you need Self expertise from LatAm, expect availability challenges and potential need to hire in North America or Europe instead.
Finding Self developers anywhere is difficult. Latin America has very few Self specialists due to the language's academic focus and lack of commercial adoption. If you need Self expertise, you're more likely to find it among computer science researchers or academics in Latin America than in the commercial technology sector.
However, Latin American researchers and academics do study historical programming languages and object-oriented theory. Universities in Brazil and Argentina, particularly, have strong computer science programs that include historical perspectives on language design.
If you're looking for meta-programming expertise informed by deep knowledge of prototype-based systems, you may find LatAm engineers with strong theoretical foundations and interest in language design who can apply those concepts to modern languages instead.
Matching Self specialists is extremely specialized. If you have a Self system requiring maintenance or development, South can help connect you with rare Self experts, though most will be located in North America or Europe rather than Latin America.
The matching process starts with understanding your specific Self requirements. We then search our network and broader engineering communities for specialists with Self experience. Given the rarity of Self expertise, you may need to consider hiring arrangement options like contract work or part-time advisory roles. Start at https://www.hireinsouth.com/start.
Self is used primarily in historical systems and academic research. It's rarely used in production technology stacks. If you have a Self system, it's likely legacy code built in the 1990s or academic research code.
No. Self is not suitable for new production systems. If you need prototype-based object-oriented design, use JavaScript or Lua. If you need meta-programming, use Python or Ruby. Self should only be considered for learning or research.
JavaScript borrowed prototype-based inheritance from Self but simplified it significantly. JavaScript is much more practical for production use. Self is valuable for understanding the theory of prototype-based OOP, while JavaScript is what you use to build systems.
Self specialists are extremely rare, making rates highly variable. Expect to pay a premium for this specialized expertise. Rates likely range from $80,000-$200,000+ annually, depending on seniority and availability.
Given extreme scarcity, 3-8 weeks is realistic. South will search our network extensively, but finding qualified candidates requires patience. You may need to expand your search beyond Latin America.
If you have a Self system, hire senior or architect level. You need someone who deeply understands the language and can make significant architectural decisions independently.
Yes. Given the rarity of Self work, part-time or contract arrangements are common. You may find someone to dedicate 20-30% of their time to your Self system.
This depends entirely on who you hire. Self expertise is so rare that geography may not be a constraint. Your specialist may be in North America, Europe, or Latin America depending on availability.
We assess deep theoretical knowledge of prototype-based object-oriented design, practical experience with Self systems, ability to articulate the language's design and influence, and capacity to maintain or extend Self code.
South guarantees 30 days to confirm fit. Given the rarity of Self expertise, you may need flexibility in arrangements, but we stand behind matches.
Yes. For LatAm-based hires, South manages full payroll, compliance, benefits, and equipment. However, Self expertise may require hiring outside LatAm, in which case we can facilitate other arrangements.
Very unlikely. Self expertise is concentrated in a tiny pool of individuals. You'll likely hire one specialist or architect, not a team.
