DEV Community

Nuri Ensing
Nuri Ensing

Posted on • Edited on

1

#UML — Understanding Lollipops and Sockets in UML: A Clear Explanation

I was trying to look up what the open ring and ball symbols in UML diagrams represent, but I found scattered and unsatisfying answers across the internet. Finally, I stumbled upon a StackOverflow post, but even then, the explanations didn’t fully satisfy me. So, I decided to post my own answer on StackOverflow: https://stackoverflow.com/questions/8307724/using-lollipops-sockets-in-uml-why-and-when/78941132#78941132

Since my posts often serve as notes for myself and the wider world, I decided to expand on the topic here.

In UML 2, you have the following symbols:

Lollipop: A small circle connected to a line: o----

Socket: An open ring with a line: ---(

Lollipops and sockets are used in UML to give a big-picture view of how different parts of your system connect and work together without diving into too much detail. They’re mostly used in component diagrams, where a component represents a module or subsystem that functions independently but can interface with the rest of the system.

Push vs Pull in UML Diagrams

In UML, lollipops (provided interfaces) and sockets (required interfaces) can be used in both pull and push interaction models:

Pull (Required Interface):

  • In this model, a component with a socket requests a service from another component. The socket represents the component’s dependency on something external to perform its functions.
  • The lollipop represents the provider of that service. The provider component exposes a lollipop, signifying that it offers a service or function that other components can consume.
  • Example: A website requires an authentication service to verify user credentials. The website (component with a socket) pulls the authentication service from the authentication provider (component with a lollipop).

Push (Provided Interface):

  • In this model, a component with a lollipop offers a service or function to other components that may need it.
  • A component with a socket can “subscribe” or accept the offered services to perform its job.
  • Example: An email notification service offers its functionality (lollipop) to a subscription service (socket) that requires notifications to be sent when certain conditions are met. The service is “pushed” to the subscriber when an event occurs.

How It Works

To keep things simple, if you see a block with a line ending in an open ring, that block (component) requires a service or information to perform its function. It represents the dependent or pulling component. Conversely, another block with a lollipop (small circle) provides the required service or functionality and represents the offering or pushing component.

The lollipop and socket connection visually shows the interaction and dependency between components, with the socket pulling services and the lollipop offering them.

Example
Image description

Consider an Authentication Service component that provides user authentication services, such as verifying usernames and passwords. Another component, like a website — for example, stackoverflow.com — needs to verify user credentials before granting access to user accounts.

Here’s how the push and pull interactions apply:

Pull (Website-Authentication):
Stackoverflow.com needs to get information from the Authentication Service. In this case, the Authentication Service component is represented with a lollipop symbol, indicating that it provides the authentication service. The Stackoverflow.com component is represented with a socket symbol, showing that it requires the authentication service to verify user credentials before granting access. The website “pulls” the service to authenticate users.

Push (Authentication-Event Trigger):
Imagine an event-driven scenario where the Authentication Service automatically pushes a notification or data to another component upon successful authentication (e.g., updating the user session or triggering a log-in event). The Authentication Service component would use its lollipop symbol to represent that it offers this event service. The receiving component, such as a user session handler, could use a socket to accept this service. The authentication success event triggers the “push” of the data to the receiver.

Conclusion

Understanding the difference between pull and push interactions in UML is crucial when designing component-based systems.

  • In the pull model, components actively request services they need (the socket pulls from the lollipop).
  • In the push model, components provide or offer their services, which other components may consume (the lollipop pushes to the socket).

By using UML’s lollipops and sockets, you can effectively represent both interaction types, providing a clear and structured overview of how system components interact.

Sentry blog image

How to reduce TTFB

In the past few years in the web dev world, we’ve seen a significant push towards rendering our websites on the server. Doing so is better for SEO and performs better on low-powered devices, but one thing we had to sacrifice is TTFB.

In this article, we’ll see how we can identify what makes our TTFB high so we can fix it.

Read more

Top comments (0)

Cloudinary image

Video API: manage, encode, and optimize for any device, channel or network condition. Deliver branded video experiences in minutes and get deep engagement insights.

Learn more

👋 Kindness is contagious

Discover a treasure trove of wisdom within this insightful piece, highly respected in the nurturing DEV Community enviroment. Developers, whether novice or expert, are encouraged to participate and add to our shared knowledge basin.

A simple "thank you" can illuminate someone's day. Express your appreciation in the comments section!

On DEV, sharing ideas smoothens our journey and strengthens our community ties. Learn something useful? Offering a quick thanks to the author is deeply appreciated.

Okay