This document discusses abstract data types (ADTs) and their implementation in various programming languages. It covers the key concepts of ADTs including data abstraction, encapsulation, information hiding, and defining the public interface separately from the private implementation. It provides examples of ADTs implemented using modules in Modula-2, packages in Ada, classes in C++, generics in Java and C#, and classes in Ruby. Parameterized and encapsulation constructs are also discussed as techniques for implementing and organizing ADTs.
This is a presentation I did for the Cedar Rapids .NET User Group (CRineta.org). It was intended to present object oriented concepts and their application in .NET and C#.
Encapsulation is one of the best concept of Object Oriented Programming. It is the base of programming . It also used by Java, .Net and Php.
Basically Encapsulation is used for abstraction of codes or you can say data binding.
This is a presentation I did for the Cedar Rapids .NET User Group (CRineta.org). It was intended to present object oriented concepts and their application in .NET and C#.
Encapsulation is one of the best concept of Object Oriented Programming. It is the base of programming . It also used by Java, .Net and Php.
Basically Encapsulation is used for abstraction of codes or you can say data binding.
Plagas, enfermedades y cambio climático: Situación prevista y medidas de adap...Plutarco Echegoyen
Geología del clima. Influencia de factores climáticos sobre las plagas. Situaciones previstas de cambio climático e impacto sobre plantas cultivadas, plantas no cultivadas y plagas. Medidas de adaptación - mitigación, recomendaciones.
it describes the main concepts of object oriented programming
For more posts : http://comsciguide.blogspot.com/
For full playlist of Interview puzzles videos : https://www.youtube.com/playlist?list=PL3v9ipJOEEPfI4zt4ExamGJwndkvg0SFc
24 standard interview puzzles: https://www.youtube.com/playlist?list=PL3v9ipJOEEPefIF4nscYOobim1iRBJTjw
Aptitude training playlist link : https://www.youtube.com/playlist?list=PL3v9ipJOEEPfumKHa02HWjCfPvGQiPZiG
for C and C++ questions, that are asked in the interviews, go through the posts in the link : http://comsciguide.blogspot.com/
for more videos, my youtube channel : https://www.youtube.com/channel/UCvMy2V7gYW7VR2WgyvLj3-A
Securing your Kubernetes cluster_ a step-by-step guide to success !KatiaHIMEUR1
Today, after several years of existence, an extremely active community and an ultra-dynamic ecosystem, Kubernetes has established itself as the de facto standard in container orchestration. Thanks to a wide range of managed services, it has never been so easy to set up a ready-to-use Kubernetes cluster.
However, this ease of use means that the subject of security in Kubernetes is often left for later, or even neglected. This exposes companies to significant risks.
In this talk, I'll show you step-by-step how to secure your Kubernetes cluster for greater peace of mind and reliability.
LF Energy Webinar: Electrical Grid Modelling and Simulation Through PowSyBl -...DanBrown980551
Do you want to learn how to model and simulate an electrical network from scratch in under an hour?
Then welcome to this PowSyBl workshop, hosted by Rte, the French Transmission System Operator (TSO)!
During the webinar, you will discover the PowSyBl ecosystem as well as handle and study an electrical network through an interactive Python notebook.
PowSyBl is an open source project hosted by LF Energy, which offers a comprehensive set of features for electrical grid modelling and simulation. Among other advanced features, PowSyBl provides:
- A fully editable and extendable library for grid component modelling;
- Visualization tools to display your network;
- Grid simulation tools, such as power flows, security analyses (with or without remedial actions) and sensitivity analyses;
The framework is mostly written in Java, with a Python binding so that Python developers can access PowSyBl functionalities as well.
What you will learn during the webinar:
- For beginners: discover PowSyBl's functionalities through a quick general presentation and the notebook, without needing any expert coding skills;
- For advanced developers: master the skills to efficiently apply PowSyBl functionalities to your real-world scenarios.
Kubernetes & AI - Beauty and the Beast !?! @KCD Istanbul 2024Tobias Schneck
As AI technology is pushing into IT I was wondering myself, as an “infrastructure container kubernetes guy”, how get this fancy AI technology get managed from an infrastructure operational view? Is it possible to apply our lovely cloud native principals as well? What benefit’s both technologies could bring to each other?
Let me take this questions and provide you a short journey through existing deployment models and use cases for AI software. On practical examples, we discuss what cloud/on-premise strategy we may need for applying it to our own infrastructure to get it to work from an enterprise perspective. I want to give an overview about infrastructure requirements and technologies, what could be beneficial or limiting your AI use cases in an enterprise environment. An interactive Demo will give you some insides, what approaches I got already working for real.
Transcript: Selling digital books in 2024: Insights from industry leaders - T...BookNet Canada
The publishing industry has been selling digital audiobooks and ebooks for over a decade and has found its groove. What’s changed? What has stayed the same? Where do we go from here? Join a group of leading sales peers from across the industry for a conversation about the lessons learned since the popularization of digital books, best practices, digital book supply chain management, and more.
Link to video recording: https://bnctechforum.ca/sessions/selling-digital-books-in-2024-insights-from-industry-leaders/
Presented by BookNet Canada on May 28, 2024, with support from the Department of Canadian Heritage.
Elevating Tactical DDD Patterns Through Object CalisthenicsDorra BARTAGUIZ
After immersing yourself in the blue book and its red counterpart, attending DDD-focused conferences, and applying tactical patterns, you're left with a crucial question: How do I ensure my design is effective? Tactical patterns within Domain-Driven Design (DDD) serve as guiding principles for creating clear and manageable domain models. However, achieving success with these patterns requires additional guidance. Interestingly, we've observed that a set of constraints initially designed for training purposes remarkably aligns with effective pattern implementation, offering a more ‘mechanical’ approach. Let's explore together how Object Calisthenics can elevate the design of your tactical DDD patterns, offering concrete help for those venturing into DDD for the first time!
Essentials of Automations: Optimizing FME Workflows with ParametersSafe Software
Are you looking to streamline your workflows and boost your projects’ efficiency? Do you find yourself searching for ways to add flexibility and control over your FME workflows? If so, you’re in the right place.
Join us for an insightful dive into the world of FME parameters, a critical element in optimizing workflow efficiency. This webinar marks the beginning of our three-part “Essentials of Automation” series. This first webinar is designed to equip you with the knowledge and skills to utilize parameters effectively: enhancing the flexibility, maintainability, and user control of your FME projects.
Here’s what you’ll gain:
- Essentials of FME Parameters: Understand the pivotal role of parameters, including Reader/Writer, Transformer, User, and FME Flow categories. Discover how they are the key to unlocking automation and optimization within your workflows.
- Practical Applications in FME Form: Delve into key user parameter types including choice, connections, and file URLs. Allow users to control how a workflow runs, making your workflows more reusable. Learn to import values and deliver the best user experience for your workflows while enhancing accuracy.
- Optimization Strategies in FME Flow: Explore the creation and strategic deployment of parameters in FME Flow, including the use of deployment and geometry parameters, to maximize workflow efficiency.
- Pro Tips for Success: Gain insights on parameterizing connections and leveraging new features like Conditional Visibility for clarity and simplicity.
We’ll wrap up with a glimpse into future webinars, followed by a Q&A session to address your specific questions surrounding this topic.
Don’t miss this opportunity to elevate your FME expertise and drive your projects to new heights of efficiency.
Epistemic Interaction - tuning interfaces to provide information for AI supportAlan Dix
Paper presented at SYNERGY workshop at AVI 2024, Genoa, Italy. 3rd June 2024
https://alandix.com/academic/papers/synergy2024-epistemic/
As machine learning integrates deeper into human-computer interactions, the concept of epistemic interaction emerges, aiming to refine these interactions to enhance system adaptability. This approach encourages minor, intentional adjustments in user behaviour to enrich the data available for system learning. This paper introduces epistemic interaction within the context of human-system communication, illustrating how deliberate interaction design can improve system understanding and adaptation. Through concrete examples, we demonstrate the potential of epistemic interaction to significantly advance human-computer interaction by leveraging intuitive human communication strategies to inform system design and functionality, offering a novel pathway for enriching user-system engagements.
UiPath Test Automation using UiPath Test Suite series, part 3DianaGray10
Welcome to UiPath Test Automation using UiPath Test Suite series part 3. In this session, we will cover desktop automation along with UI automation.
Topics covered:
UI automation Introduction,
UI automation Sample
Desktop automation flow
Pradeep Chinnala, Senior Consultant Automation Developer @WonderBotz and UiPath MVP
Deepak Rai, Automation Practice Lead, Boundaryless Group and UiPath MVP
Connector Corner: Automate dynamic content and events by pushing a buttonDianaGray10
Here is something new! In our next Connector Corner webinar, we will demonstrate how you can use a single workflow to:
Create a campaign using Mailchimp with merge tags/fields
Send an interactive Slack channel message (using buttons)
Have the message received by managers and peers along with a test email for review
But there’s more:
In a second workflow supporting the same use case, you’ll see:
Your campaign sent to target colleagues for approval
If the “Approve” button is clicked, a Jira/Zendesk ticket is created for the marketing design team
But—if the “Reject” button is pushed, colleagues will be alerted via Slack message
Join us to learn more about this new, human-in-the-loop capability, brought to you by Integration Service connectors.
And...
Speakers:
Akshay Agnihotri, Product Manager
Charlie Greenberg, Host
State of ICS and IoT Cyber Threat Landscape Report 2024 previewPrayukth K V
The IoT and OT threat landscape report has been prepared by the Threat Research Team at Sectrio using data from Sectrio, cyber threat intelligence farming facilities spread across over 85 cities around the world. In addition, Sectrio also runs AI-based advanced threat and payload engagement facilities that serve as sinks to attract and engage sophisticated threat actors, and newer malware including new variants and latent threats that are at an earlier stage of development.
The latest edition of the OT/ICS and IoT security Threat Landscape Report 2024 also covers:
State of global ICS asset and network exposure
Sectoral targets and attacks as well as the cost of ransom
Global APT activity, AI usage, actor and tactic profiles, and implications
Rise in volumes of AI-powered cyberattacks
Major cyber events in 2024
Malware and malicious payload trends
Cyberattack types and targets
Vulnerability exploit attempts on CVEs
Attacks on counties – USA
Expansion of bot farms – how, where, and why
In-depth analysis of the cyber threat landscape across North America, South America, Europe, APAC, and the Middle East
Why are attacks on smart factories rising?
Cyber risk predictions
Axis of attacks – Europe
Systemic attacks in the Middle East
Download the full report from here:
https://sectrio.com/resources/ot-threat-landscape-reports/sectrio-releases-ot-ics-and-iot-security-threat-landscape-report-2024/
UiPath Test Automation using UiPath Test Suite series, part 4DianaGray10
Welcome to UiPath Test Automation using UiPath Test Suite series part 4. In this session, we will cover Test Manager overview along with SAP heatmap.
The UiPath Test Manager overview with SAP heatmap webinar offers a concise yet comprehensive exploration of the role of a Test Manager within SAP environments, coupled with the utilization of heatmaps for effective testing strategies.
Participants will gain insights into the responsibilities, challenges, and best practices associated with test management in SAP projects. Additionally, the webinar delves into the significance of heatmaps as a visual aid for identifying testing priorities, areas of risk, and resource allocation within SAP landscapes. Through this session, attendees can expect to enhance their understanding of test management principles while learning practical approaches to optimize testing processes in SAP environments using heatmap visualization techniques
What will you get from this session?
1. Insights into SAP testing best practices
2. Heatmap utilization for testing
3. Optimization of testing processes
4. Demo
Topics covered:
Execution from the test manager
Orchestrator execution result
Defect reporting
SAP heatmap example with demo
Speaker:
Deepak Rai, Automation Practice Lead, Boundaryless Group and UiPath MVP
UiPath Test Automation using UiPath Test Suite series, part 4
Abstract data types
1. Abstract Data Types
• Data abstraction, or abstract data types, is a programming
methodology where one defines not only the data
structure to be used, but the processes to manipulate the
structure
– like process abstraction, ADTs can be supported directly by
programming languages
• To support it, there needs to be mechanisms for
– defining data structures
– encapsulation of data structures and their routines to manipulate
the structures into one unit
• by placing all definitions in one unit, it can be compiled at one time
– information hiding to protect the data structure from outside
interference or manipulation
• the data structure should only be accessible from code encapsulated with
it so that the structure is hidden and protected from the outside
• objects are one way to implement ADTs, but because objects have
additional properties, we defer discussion of them until the next chapter
2. ADT Design Issues
• Encapsulation: it must be possible to define a unit that
contains a data structure and the subprograms that
access (manipulate) it
– design issues:
• will ADT access be restricted through pointers?
• can ADTs be parameterized (size and/or type)?
• Information hiding: controlling access to the data
structure through some form of interface so that it
cannot be directly manipulated by external code
– this is often done by using two sections of an ADT definition
• public part (interface) constitutes those elements that can be accessed
externally (often the interface permits only access to subprograms and
constants)
• the private part, which remains secure because it is only accessible by
subprograms of the ADT itself
3. Modula-2 ADTs
• Unit for encapsulation called a module
– modules can be combined to form libraries of ADTs
• To define a module:
– definition module: the interface containing a partial or
complete type definition (data structure) and the subprogram
headers and parameters
– implementation module: the portion of the data structure that
is to be hidden, along with all operation subprograms
• If the complete type declaration is given in the definition
module, the type is “transparent” otherwise it is
“opaque”
– opaque types represent true ADTs and must be accessed
through pointers
• this restriction allows the ADT to be entirely hidden from user
programs since the user program need only define a pointer
4. ADTs in Ada
• The encapsulation construct is the package
• Packages consist of two parts:
– specification package (the public or interface part)
– body package (the hidden or private part)
• The two packages can be compiled separately
– but only if specification package is compiled first
• The specification package must include details of the data
structure itself
– to preserve information hiding, the data structure’s definition can follow
the word private denoting that the following is hidden
• Ada offers three forms of ADTs
– those without information hiding, and thus are not true ADTs
– those that preserve information hiding by specifying that the data structure
is private
– those that specify that the data structure is limited private
• all ADTs have built-in operations for assignment and equality except for
limited private ADTs which have no built-in operations at all
5. Example Part I
package Stack_Pack is
type Stack_Type is limited private;
Max_Size : constant := 100;
function Empty(Stk : in Stack_Type) return Boolean;
procedure Push(Stk : in out Stack_Type; Element : in Integer);
procedure Pop(Stk : in out Stack_Type);
function Top(Stk : in Stack_Type) return Integer;
private
type List_Type is array (1..Max_Size) of Integer;
type Stack_Type is
record
List : List_Type;
Topsub : Integer range 0..Max_Size := 0;
end record;
end Stack_Pack;
The specification package
for a stack ADT – see the next
slide for the body package
The actual ADT
definition must either
appear in the open
section (e.g., the public
part) or in the private
section
An alternative implementation to this approach is to
define a pointer in the private section of this package and
define the actual Stack_Type ADT in the body package.
This is discussed in more detail in the notes section of this
slide.
6. Example Part II
with Ada.Text_IO; use Ada.Text_IO;
package body Stack_Pack is
function Empty(Stk : in Stack_Type) return Boolean is
begin
return Stk.Topsub = 0;
end Empty;
procedure Push(Stk : in out Stack_Type; Element : in Integer) is
begin
if Stk.Topsub >= Max_Size then
Put_Line(“ERROR – Stack overflow”);
else
Stk.Topsub := Stk.Topsub +1; Stk.List(Topsub):=Element;
end if;
end Push;
procedure Pop(Stk : in out Stack_Type) is
begin … end Pop;
function Top(Stk : in Stack_Type) return Integer is
begin … end Top;
end Stack_Pack;
The rest of the implementation
can be found on page 481
7. C++ ADTs
• C++ offers two mechanisms for building data structures:
the struct and the class
– because the struct does not have a mechanism for information
hiding, it can only offer encapsulation, so for a true ADT, we
must use C++s object
– C++ classes contain both visible (public) and hidden (private)
components (as well as protected)
– C++ instances can be static, heap-dynamic and stack-dynamic
• the lifetime of an instance ends when it reaches the end of the scope of
where it was declared
• a stack-dynamic object may have heap-dynamic data so that parts of the
object may continue even though the instant is deallocated
– we defer most of our discussion of objects in C++ to the next
chapter, but we will see an example next
8. C++ Example
#include <iostream.h>
class stack {
private:
int *stackPtr;
int max;
int topPtr;
public:
stack( ) { // constructor
stackPtr = new int [100];
max = 99;
topPtr = -1;
}
~stack( ) {delete [ ] stackPtr;} // destructor
void push(int number) {…} // details omitted
void pop( ) {…}
int top( ) {…}
int empty( ) {…}
Unlike the Ada example, in C++, the
entire definition is encapsulated in one
location
Information hiding is preserved through
the use of a private part with the interface
being defined in the public part
Any methods that are to be defined in this
class but not accessible outside of the
class would also be defined in the private
section
9. Java, C# and Ruby ADTs
• All three languages support ADTs through classes
– Java permits no stand-alone functions, only methods defined
in class definitions and unlike C++, referenced through
reference variables (pointers), therefore, in Java, every data
structure is an ADT
• it is up to the programmer as to whether information hiding is enforced
or not
– C# borrows from both C++ and Java but primarily from Java,
where all objects are heap dynamic, modifiers are private,
public, protected, but C# also offers
• internal and protected internal modifiers which are used for assemblies
(cross-platform objects), and methods that can serve as both accessors
and mutators (see the example on page 500-501)
– Ruby requires that all class variables be private, and all
methods default to being public (but the programmer can
change this)
• class variables do not have to be explicitly declared in Ruby, see the
example on page 502-04
• we look at Ruby in more detail in chapter 12
10. Parameterized ADTs
• The ability to define an ADT
where the type and/or size is
specified generically so that a
specific version can be
generated later
– a stack defined without
specifying the element type
(integer vs. string vs. float, etc)
– a stack defined without a
restriction on the size of the stack
– Ada, C++, Java and C# all have
this capability
• The approach is to replace the
type definition with a place
holder that is filled in later
In ADA:
generic
Max_Size : positive;
type Element_Type is private;
… rest of ADT as before except that
Element_Type replaces Integer
and Max_Size as a constant is
removed
now we instantiate our ADT:
package Integer_Stack is new
Generic_Stack(100, Integer);
11. Parameterized ADTs Continued
• In C++, parameterized ADTs are implemented as
templated classes
– to change the stack class’ size, only change the constructor to
receive the size as a parameter, which is used to establish the
size of the array
– to change the stack’s type, the class is now defined as a
template using template <class Type> where Type is the
place-holder to be filled in by a specific type at run-time
• In both Ada and C++, the parameterized ADT
definition is generated at compile-time
– the new statement signals that a new package should be
generated by the compiler
• in C++, if two definitions ask for the same type of ADT, only 1 set of
source code is generated, in Ada, the same source code is generated
twice!
• In Java and C#, parameterized ADTs are implemented
as generic classes (you should have covered this in 360
for Java, so we skip it here)
12. Encapsulation Constructs
• For large programs, to avoid having to recompile all code when
one section changes
– code can be grouped into logically related chunks called encapsulations
• one approach is the nested subprogram, place logically related subprograms
inside of the subprograms that commonly call them, although this approach is
not available in C-languages since nesting of subprograms is not possible
• use a header file (C, C++) and place logically related functions in the same
file, distributing the program across multiple files
– C++ goes beyond simple header files and includes the notation of a friend which
has access to private definitions
• Ada packages (which can be compiled separately) can include any number of
data and subprogram declarations so that they can contain interfaces for
multiple ADTs
• C# assemblies that can share code with other software written in the .NET
environment
• Each language has some technique for then using the named
encapsulation, sometimes called a namespace
– see the notes section of this slide for details in various languages
Editor's Notes
Programmers and computer science in general greatly improved on programming methodologies over time as they learned about good and bad programming habits, and what programming language constructs were needed to help support good habits. One major change in programming emphasis arose in the late 70s/early 80s as a response to programmers creating data structures as needed, rather than in a principled manner. The solution is known as abstract data types, to support the need of data abstraction.
Since you have already studied abstract data types in CSC 360, we will skip over the example illustrated in the textbook in section 11.2 and concentrate on how languages support them.
Early languages had no support for ADTs. Early FORTRAN had no structures other than arrays. COBOL allowed one to define a structure but had no mechanisms for encapsulation or information hiding. PL/I included all of the various data structures as part of the language so that, while you could declare a variable to be of a specific data structure type and access it through built-in processes, you could not define your own. Simula-67 was the first to offer the ability to define your own data structures, but this idea was not popularized until ALGOL-68. Its two primary successors, Pascal and C, popularized the notion of programmer defined structures, which has been provided in nearly every language since. However, neither of these languages has mechanisms for information hiding, and they only have weak support for encapsulation (encapsulation is not mandatory).
By restricting an ADT’s access to be via pointer, one can modify the ADT code and recompile that definition without having to recompile any user code. For instance, if I define an ADT in a file and compile it, and then you write a program to use my ADT, fine. Later, I modify the structure of my ADT (without modifying the interface) and recompile it and make the new object file available to you. You will not have to recompile your code if your code accesses the ADT through a pointer. However, if your code declares a variable of the ADT structure itself, then your code MUST be recompiled because I have changed the storage requirements for the ADT.
Simula 67 was the first language to provide a facility for user-defined classes. Objects were dynamically allocated, which was fairly unique at the time, and the class construct combined both data structure definition and the subprograms to operate on the variables, making Simula-67 the first language to offer encapsulation. However, Simula 67 did not offer a mechanism for information hiding, so the Simula 67 class fails as an ADT. ALGOL-68 would also permit the user to define data structures but had no encapsulation or information hiding.
The form of a class in Simula67 is
class class_name;
begin
variable declarations here
subprogram definitions of operators here
code section here
end class_name;
For most languages, ADTs are implemented by pointers and so assignment merely copies pointer values so that one pointer now points at the other ADT, rather than copying the data structure itself. In Ada, assignment means “copy the data structure into a new memory location”. Similarly, equality in most languages tests the two pointers to see if they point at the same memory location, but in Ada, equality tests to see if two data structures have the same data values. While assignment and equality may be less efficient in Ada than other languages, it provides more flexibility in that these operations are more meaningful.
NOTE: because we ar eusing List_Type in our Stack_Type definition, List_Type must be defined first, and therefore it is defined prior to our actual Stack ADT, which is a record with a List and a Topsub. The List_Type does not have to be defined in either the private section or in this package as long as it is defined somewhere, but it makes the most sense to define it where it is because it should also be hidden.
By making the ADT definition above a pointer to a stack record, and defining the actual data structure in the body package, it makes our definition a little cleaner – that is, we are not defining the data structure in one place and the code elsewhere, we are defining the interface in one place and the structure and code in the body package. The specification package would look like this instead:
private
type Stack_Type;
type Stack_Ptr is access Stack_Type;
And then define Stack_Type itself (along with List_Type) in the body package.
While this is cleaner, there is a drawback to this approach in that a user program can declare a Stack_Ptr and manipulate it without having it point at a Stack_Type and therefore lead to run-time errors. In addition, equality and assignment are now of pointers and therefore do not copy the data structure or compare the data structure as is planned in Ada.
Notice that the actual ADT definition is omitted in the body package because it had already been defined in the specification package
The author expresses concern regarding the use of pointers to ADTs. In this Ada example, the data structure is a record (like a struct), and not a pointer to a record (struct). There are advantages and disadvantages to this approach. The primary advantages are that we do not have to perform pointer dereferencing every time we want to access the data structure and that we don’t have typical pointer concerns (aliases, dangling pointers, lost objects). However, we also have disadvantages – assignment requires copying items between two data structures, and equality means testing items between two data structures.
The main advantage of using a pointer to a data structure however is to get away from the need to recompile code as discussed on the first slide’s notes for this chapter. The Modula-2 approach where all data structures are pointed to is cleaner than the Ada approach where the programmer has a choice. The author really seems to like the Ada approach better.
Note that C/C++ structs do not support encapsulation at all, however you can use structs and build your own encapsulation through the use of a header file.
We explore classes in chapter 12, so we won’t cover the above example in any detail here.
Note about Java and generics:
Prior to Java 1.5, generics were not available. You could however simulate this through the use of polymorphism. Recall that if you had some class Parent and subclass Child, and a method called foo in Parent, then an object of either class could call upon foo, so foo becomes a generic method. If you could extend this concept by making the ADT store data of type Objects, then since all object types descend from Object, the ADT can then implement methods that operate on the type Object but still permit you to store a specific type in the ADT (for instance, if the ADT is a stack, you could store Strings or Colors there). If you were to store a primitive type, you would use the appropriate wrapper classes (such as Integer to store int values). So you could make a generic ADT in Java through this technique. The only problem with this is to obtain a specific item from the ADT would require casting the Object to its right type. You can see a brief example of this on page 507-8 where the ADT is used to store Integers.
Java 1.5 cleans this up by permitting true generic objects for parameterized ADTs.
The idea of a namespace is that it allows units of a program (e.g., function names) to have the same name but be different sets of code – a namespace is a container (encapsulation) in which a given name can be recognized. Here, we look at how namespaces are specified in some of the more common languages.
C++ uses namespace to specify a namespace. To access elements of a namespace, you use the :: operator. The :: is known as the scope resolution operator. The :: notation is needed when two libraries have different definitions but share the same named item. An example might be having a namespace for MyStack and referencing a variable of that encapsulation using MyStack::topPtr.
Java uses packages which combine one or more class definitions. Without a package, special access can be granted between classes (we cover this in chapter 12). We use import to import an entire package or a specific class from a package:
import java.io.*; imports all classes in the package
import java.io.JOptionPane; imports only the selected class
Since Java is OO, the use of the namespace is governed by interaction with objects. Therefore, Java does not permit imported classes to share names, but names of different class’ methods, variables and constants can be shared. You would address a shared item by referencing the class, as in aStack.topPtr or aStack.pop();
Ada also uses packages. In Ada, the with statement is used to include a package, and the uses statement is used to specify the specific definition (ADT) desired from that package. For example:
with Ada.Text_IO;
uses Ada.Text_IO;
oruses Ada.Text_IO.Put;
Ruby uses modules, which are collections of methods and constants. Modules are unlike classes though as in that a Module is not a definition that can be instantiated or extended.