A large body of existing, sequential applications must be migrated to multicore platforms with maximum transparency. To achieve this, techniques for automatic parallelization must be pushed to their limits, and current shared memory programming paradigms must be reconsidered with respect to their ease of use, performance characteristics and ability to support a wide range of programming needs. Despite advances in automated and dynamic exposure of exploitable parallelism, the application developer will frequently need to support the process of code migration by making the parallelism in a program explicit. One of the most straightforward ways in which this can be done is by inserting the directives or pragmas of the portable OpenMP shared memory programming interface, a de facto standard. In this paper we discuss the programming implications of this radical change in the approach to building mainstream processors. We briefly consider the suitability of existing and recently proposed programming models to satisfy multicore application development needs, arguing that OpenMP is the most broadly appropriate of them for higher level multicore programming. Yet OpenMP was designed before the multicore 'revolution'. We discuss some ways in which the implementation of OpenMP might be improved to meet scalability demands posed by emerging platforms and introduce a potential extension that might simplify application development in some cases. We briefly discuss our own OpenMP implementation. Finally, we offer our conclusions on the ability of the state of the art in programming models and their implementations to satisfy the needs of multicore programming.