Dynamic programming languages have become increasingly popular and have been used to implement a range of applications. Meanwhile, multicore processors have become the norm, even for desktop computers and mobile devices. Therefore, programmers must turn to parallelism as a means to improve performance. However, concurrent programming remains difficult. Besides, despite improvements in static languages, we find dynamic languages are still lacking in concurrency support. In this thesis, we argue that the main problem with concurrent programming is unpredictability - unexpected program behaviors, such as returning out-of-thin-air values. We observe that unpredictability is most likely to happen when shared memory is used. Consequently, we propose a concurrency communication model to discipline shared memory in dynamic languages. The model is based on the emerging concurrency patterns of not sharing data by default, data immutability, and types and effects (which we turn into capabilities). It mandates the use of shareable objects to share data. Besides, it establishes that the only means to share a shareable object is to use message passing. Shareable objects can be shared as read-write or read-only, which allows both individual read-write access and parallel read-only access to data. We implemented a prototype in Lua, called luashare, to experiment with the model in practice, as well as to carry out a general performance evaluation. The evaluation showed us that safe data sharing makes it easier to allow for communication among threads. Besides, there are situations where copying data around is simply not an option. However, enforcing control over shareable objects has a performance cost, in particular when working with nested objects.